1 //===-- SBAddress.h ---------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef LLDB_SBAddress_h_ 11 #define LLDB_SBAddress_h_ 12 13 #include "lldb/API/SBDefines.h" 14 #include "lldb/API/SBModule.h" 15 16 namespace lldb { 17 18 class LLDB_API SBAddress { 19 public: 20 SBAddress(); 21 22 SBAddress(const lldb::SBAddress &rhs); 23 24 SBAddress(lldb::SBSection section, lldb::addr_t offset); 25 26 // Create an address by resolving a load address using the supplied target 27 SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target); 28 29 ~SBAddress(); 30 31 const lldb::SBAddress &operator=(const lldb::SBAddress &rhs); 32 33 bool IsValid() const; 34 35 void Clear(); 36 37 addr_t GetFileAddress() const; 38 39 addr_t GetLoadAddress(const lldb::SBTarget &target) const; 40 41 void SetAddress(lldb::SBSection section, lldb::addr_t offset); 42 43 void SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target); 44 bool OffsetAddress(addr_t offset); 45 46 bool GetDescription(lldb::SBStream &description); 47 48 // The following queries can lookup symbol information for a given address. 49 // An address might refer to code or data from an existing module, or it 50 // might refer to something on the stack or heap. The following functions 51 // will only return valid values if the address has been resolved to a code 52 // or data address using "void SBAddress::SetLoadAddress(...)" or 53 // "lldb::SBAddress SBTarget::ResolveLoadAddress (...)". 54 lldb::SBSymbolContext GetSymbolContext(uint32_t resolve_scope); 55 56 // The following functions grab individual objects for a given address and 57 // are less efficient if you want more than one symbol related objects. Use 58 // one of the following when you want multiple debug symbol related objects 59 // for an address: 60 // lldb::SBSymbolContext SBAddress::GetSymbolContext (uint32_t 61 // resolve_scope); 62 // lldb::SBSymbolContext SBTarget::ResolveSymbolContextForAddress (const 63 // SBAddress &addr, uint32_t resolve_scope); 64 // One or more bits from the SymbolContextItem enumerations can be logically 65 // OR'ed together to more efficiently retrieve multiple symbol objects. 66 67 lldb::SBSection GetSection(); 68 69 lldb::addr_t GetOffset(); 70 71 lldb::SBModule GetModule(); 72 73 lldb::SBCompileUnit GetCompileUnit(); 74 75 lldb::SBFunction GetFunction(); 76 77 lldb::SBBlock GetBlock(); 78 79 lldb::SBSymbol GetSymbol(); 80 81 lldb::SBLineEntry GetLineEntry(); 82 83 protected: 84 friend class SBBlock; 85 friend class SBBreakpoint; 86 friend class SBBreakpointLocation; 87 friend class SBFrame; 88 friend class SBFunction; 89 friend class SBLineEntry; 90 friend class SBInstruction; 91 friend class SBModule; 92 friend class SBSection; 93 friend class SBSymbol; 94 friend class SBSymbolContext; 95 friend class SBTarget; 96 friend class SBThread; 97 friend class SBThreadPlan; 98 friend class SBValue; 99 friend class SBQueueItem; 100 101 lldb_private::Address *operator->(); 102 103 const lldb_private::Address *operator->() const; 104 105 friend bool LLDB_API operator==(const SBAddress &lhs, const SBAddress &rhs); 106 107 lldb_private::Address *get(); 108 109 lldb_private::Address &ref(); 110 111 const lldb_private::Address &ref() const; 112 113 SBAddress(const lldb_private::Address *lldb_object_ptr); 114 115 void SetAddress(const lldb_private::Address *lldb_object_ptr); 116 117 private: 118 std::unique_ptr<lldb_private::Address> m_opaque_ap; 119 }; 120 121 bool LLDB_API operator==(const SBAddress &lhs, const SBAddress &rhs); 122 123 } // namespace lldb 124 125 #endif // LLDB_SBAddress_h_ 126