File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/lldb/include/lldb/Breakpoint

usr / src / contrib / llvm-project / lldb / include / lldb / Breakpoint /

📁 ..
📄 Breakpoint.h(24.45 KB)
📄 BreakpointID.h(3.22 KB)
📄 BreakpointIDList.h(2.34 KB)
📄 BreakpointList.h(5.6 KB)
📄 BreakpointLocation.h(11.94 KB)
📄 BreakpointLocationCollection.h(5.67 KB)
📄 BreakpointLocationList.h(7.13 KB)
📄 BreakpointName.h(6.13 KB)
📄 BreakpointOptions.h(13.73 KB)
📄 BreakpointPrecondition.h(931 B)
📄 BreakpointResolver.h(8.49 KB)
📄 BreakpointResolverAddress.h(3.11 KB)
📄 BreakpointResolverFileLine.h(2.94 KB)
📄 BreakpointResolverFileRegex.h(2.9 KB)
📄 BreakpointResolverName.h(3.69 KB)
📄 BreakpointResolverScripted.h(2.94 KB)
📄 BreakpointSite.h(8.58 KB)
📄 BreakpointSiteList.h(5.44 KB)
📄 Stoppoint.h(1.05 KB)
📄 StoppointCallbackContext.h(1.82 KB)
📄 StoppointLocation.h(2.96 KB)
📄 Watchpoint.h(7.53 KB)
📄 WatchpointList.h(6.13 KB)
📄 WatchpointOptions.h(7.04 KB)

Editing: BreakpointLocationList.h

//===-- BreakpointLocationList.h --------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef LLDB_BREAKPOINT_BREAKPOINTLOCATIONLIST_H
#define LLDB_BREAKPOINT_BREAKPOINTLOCATIONLIST_H

#include <map>
#include <mutex>
#include <vector>

#include "lldb/Core/Address.h"
#include "lldb/Utility/Iterable.h"
#include "lldb/lldb-private.h"

namespace lldb_private {

/// \class BreakpointLocationList BreakpointLocationList.h
/// "lldb/Breakpoint/BreakpointLocationList.h" This class is used by
/// Breakpoint to manage a list of breakpoint locations, each breakpoint
/// location in the list has a unique ID, and is unique by Address as well.
class BreakpointLocationList {
  // Only Breakpoints can make the location list, or add elements to it. This
  // is not just some random collection of locations.  Rather, the act of
  // adding the location to this list sets its ID, and implicitly all the
  // locations have the same breakpoint ID as well.  If you need a generic
  // container for breakpoint locations, use BreakpointLocationCollection.
  friend class Breakpoint;

public:
  virtual ~BreakpointLocationList();

/// Standard "Dump" method.  At present it does nothing.
  void Dump(Stream *s) const;

/// Returns a shared pointer to the breakpoint location at address \a addr -
  /// const version.
  ///
  /// \param[in] addr
  ///     The address to look for.
  ///
  /// \result
  ///     A shared pointer to the breakpoint. May contain a nullptr
  ///     pointer if the breakpoint doesn't exist.
  const lldb::BreakpointLocationSP FindByAddress(const Address &addr) const;

/// Returns a shared pointer to the breakpoint location with id \a breakID,
  /// const version.
  ///
  /// \param[in] breakID
  ///     The breakpoint location ID to seek for.
  ///
  /// \result
  ///     A shared pointer to the breakpoint. May contain a nullptr
  ///     pointer if the breakpoint doesn't exist.
  lldb::BreakpointLocationSP FindByID(lldb::break_id_t breakID) const;

/// Returns the breakpoint location id to the breakpoint location at address
  /// \a addr.
  ///
  /// \param[in] addr
  ///     The address to match.
  ///
  /// \result
  ///     The ID of the breakpoint location, or LLDB_INVALID_BREAK_ID.
  lldb::break_id_t FindIDByAddress(const Address &addr);

/// Returns a breakpoint location list of the breakpoint locations in the
  /// module \a module.  This list is allocated, and owned by the caller.
  ///
  /// \param[in] module
  ///     The module to seek in.
  ///
  /// \param[in] bp_loc_list
  ///     A breakpoint collection that gets any breakpoint locations
  ///     that match \a module appended to.
  ///
  /// \result
  ///     The number of matches
  size_t FindInModule(Module *module,
                      BreakpointLocationCollection &bp_loc_list);

/// Returns a shared pointer to the breakpoint location with index \a i.
  ///
  /// \param[in] i
  ///     The breakpoint location index to seek for.
  ///
  /// \result
  ///     A shared pointer to the breakpoint. May contain a nullptr
  ///     pointer if the breakpoint doesn't exist.
  lldb::BreakpointLocationSP GetByIndex(size_t i);

/// Returns a shared pointer to the breakpoint location with index \a i,
  /// const version.
  ///
  /// \param[in] i
  ///     The breakpoint location index to seek for.
  ///
  /// \result
  ///     A shared pointer to the breakpoint. May contain a nullptr
  ///     pointer if the breakpoint doesn't exist.
  const lldb::BreakpointLocationSP GetByIndex(size_t i) const;

/// Removes all the locations in this list from their breakpoint site owners
  /// list.
  void ClearAllBreakpointSites();

/// Tells all the breakpoint locations in this list to attempt to resolve
  /// any possible breakpoint sites.
  void ResolveAllBreakpointSites();

/// Returns the number of breakpoint locations in this list with resolved
  /// breakpoints.
  ///
  /// \result
  ///     Number of qualifying breakpoint locations.
  size_t GetNumResolvedLocations() const;

/// Returns the number hit count of all locations in this list.
  ///
  /// \result
  ///     Hit count of all locations in this list.
  uint32_t GetHitCount() const;

/// Enquires of the breakpoint location in this list with ID \a breakID
  /// whether we should stop.
  ///
  /// \param[in] context
  ///     This contains the information about this stop.
  ///
  /// \param[in] breakID
  ///     This break ID that we hit.
  ///
  /// \return
  ///     \b true if we should stop, \b false otherwise.
  bool ShouldStop(StoppointCallbackContext *context, lldb::break_id_t breakID);

/// Returns the number of elements in this breakpoint location list.
  ///
  /// \result
  ///     The number of elements.
  size_t GetSize() const { return m_locations.size(); }

/// Print a description of the breakpoint locations in this list to the
  /// stream \a s.
  ///
  /// \param[in] s
  ///     The stream to which to print the description.
  ///
  /// \param[in] level
  ///     The description level that indicates the detail level to
  ///     provide.
  ///
  /// \see lldb::DescriptionLevel
  void GetDescription(Stream *s, lldb::DescriptionLevel level);

protected:
  /// This is the standard constructor.
  ///
  /// It creates an empty breakpoint location list. It is protected here
  /// because only Breakpoints are allowed to create the breakpoint location
  /// list.
  BreakpointLocationList(Breakpoint &owner);

lldb::BreakpointLocationSP Create(const Address &addr,
                                    bool resolve_indirect_symbols);

void StartRecordingNewLocations(BreakpointLocationCollection &new_locations);

void StopRecordingNewLocations();

lldb::BreakpointLocationSP AddLocation(const Address &addr,
                                         bool resolve_indirect_symbols,
                                         bool *new_location = nullptr);

void SwapLocation(lldb::BreakpointLocationSP to_location_sp,
                    lldb::BreakpointLocationSP from_location_sp);

bool RemoveLocation(const lldb::BreakpointLocationSP &bp_loc_sp);

void RemoveLocationByIndex(size_t idx);

void RemoveInvalidLocations(const ArchSpec &arch);

void Compact();

typedef std::vector<lldb::BreakpointLocationSP> collection;
  typedef std::map<lldb_private::Address, lldb::BreakpointLocationSP,
                   Address::ModulePointerAndOffsetLessThanFunctionObject>
      addr_map;

Breakpoint &m_owner;
  collection m_locations; // Vector of locations, sorted by ID
  addr_map m_address_to_location;
  mutable std::recursive_mutex m_mutex;
  lldb::break_id_t m_next_id;
  BreakpointLocationCollection *m_new_location_recorder;

public:
  typedef AdaptedIterable<collection, lldb::BreakpointLocationSP,
                          vector_adapter>
      BreakpointLocationIterable;

BreakpointLocationIterable BreakpointLocations() {
    return BreakpointLocationIterable(m_locations);
  }
};

} // namespace lldb_private

#endif // LLDB_BREAKPOINT_BREAKPOINTLOCATIONLIST_H

003 File Manager

Editing: BreakpointLocationList.h

Upload File

Create Folder