1 //===-- SBModule.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_SBModule_h_ 11 #define LLDB_SBModule_h_ 12 13 #include "lldb/API/SBDefines.h" 14 #include "lldb/API/SBError.h" 15 #include "lldb/API/SBSection.h" 16 #include "lldb/API/SBSymbolContext.h" 17 #include "lldb/API/SBValueList.h" 18 19 namespace lldb { 20 21 class SBModule 22 { 23 public: 24 25 SBModule (); 26 27 SBModule (const SBModule &rhs); 28 29 SBModule (const SBModuleSpec &module_spec); 30 31 const SBModule & 32 operator = (const SBModule &rhs); 33 34 SBModule (lldb::SBProcess &process, 35 lldb::addr_t header_addr); 36 37 ~SBModule (); 38 39 bool 40 IsValid () const; 41 42 void 43 Clear(); 44 45 //------------------------------------------------------------------ 46 /// Get const accessor for the module file specification. 47 /// 48 /// This function returns the file for the module on the host system 49 /// that is running LLDB. This can differ from the path on the 50 /// platform since we might be doing remote debugging. 51 /// 52 /// @return 53 /// A const reference to the file specification object. 54 //------------------------------------------------------------------ 55 lldb::SBFileSpec 56 GetFileSpec () const; 57 58 //------------------------------------------------------------------ 59 /// Get accessor for the module platform file specification. 60 /// 61 /// Platform file refers to the path of the module as it is known on 62 /// the remote system on which it is being debugged. For local 63 /// debugging this is always the same as Module::GetFileSpec(). But 64 /// remote debugging might mention a file '/usr/lib/liba.dylib' 65 /// which might be locally downloaded and cached. In this case the 66 /// platform file could be something like: 67 /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib' 68 /// The file could also be cached in a local developer kit directory. 69 /// 70 /// @return 71 /// A const reference to the file specification object. 72 //------------------------------------------------------------------ 73 lldb::SBFileSpec 74 GetPlatformFileSpec () const; 75 76 bool 77 SetPlatformFileSpec (const lldb::SBFileSpec &platform_file); 78 79 lldb::ByteOrder 80 GetByteOrder (); 81 82 uint32_t 83 GetAddressByteSize(); 84 85 const char * 86 GetTriple (); 87 88 const uint8_t * 89 GetUUIDBytes () const; 90 91 const char * 92 GetUUIDString () const; 93 94 bool 95 operator == (const lldb::SBModule &rhs) const; 96 97 bool 98 operator != (const lldb::SBModule &rhs) const; 99 100 lldb::SBSection 101 FindSection (const char *sect_name); 102 103 lldb::SBAddress 104 ResolveFileAddress (lldb::addr_t vm_addr); 105 106 lldb::SBSymbolContext 107 ResolveSymbolContextForAddress (const lldb::SBAddress& addr, 108 uint32_t resolve_scope); 109 110 bool 111 GetDescription (lldb::SBStream &description); 112 113 uint32_t 114 GetNumCompileUnits(); 115 116 lldb::SBCompileUnit 117 GetCompileUnitAtIndex (uint32_t); 118 119 size_t 120 GetNumSymbols (); 121 122 lldb::SBSymbol 123 GetSymbolAtIndex (size_t idx); 124 125 lldb::SBSymbol 126 FindSymbol (const char *name, 127 lldb::SymbolType type = eSymbolTypeAny); 128 129 lldb::SBSymbolContextList 130 FindSymbols (const char *name, 131 lldb::SymbolType type = eSymbolTypeAny); 132 133 size_t 134 GetNumSections (); 135 136 lldb::SBSection 137 GetSectionAtIndex (size_t idx); 138 //------------------------------------------------------------------ 139 /// Find functions by name. 140 /// 141 /// @param[in] name 142 /// The name of the function we are looking for. 143 /// 144 /// @param[in] name_type_mask 145 /// A logical OR of one or more FunctionNameType enum bits that 146 /// indicate what kind of names should be used when doing the 147 /// lookup. Bits include fully qualified names, base names, 148 /// C++ methods, or ObjC selectors. 149 /// See FunctionNameType for more details. 150 /// 151 /// @return 152 /// A lldb::SBSymbolContextList that gets filled in with all of 153 /// the symbol contexts for all the matches. 154 //------------------------------------------------------------------ 155 lldb::SBSymbolContextList 156 FindFunctions (const char *name, 157 uint32_t name_type_mask = lldb::eFunctionNameTypeAny); 158 159 //------------------------------------------------------------------ 160 /// Find global and static variables by name. 161 /// 162 /// @param[in] target 163 /// A valid SBTarget instance representing the debuggee. 164 /// 165 /// @param[in] name 166 /// The name of the global or static variable we are looking 167 /// for. 168 /// 169 /// @param[in] max_matches 170 /// Allow the number of matches to be limited to \a max_matches. 171 /// 172 /// @return 173 /// A list of matched variables in an SBValueList. 174 //------------------------------------------------------------------ 175 lldb::SBValueList 176 FindGlobalVariables (lldb::SBTarget &target, 177 const char *name, 178 uint32_t max_matches); 179 180 //------------------------------------------------------------------ 181 /// Find the first global (or static) variable by name. 182 /// 183 /// @param[in] target 184 /// A valid SBTarget instance representing the debuggee. 185 /// 186 /// @param[in] name 187 /// The name of the global or static variable we are looking 188 /// for. 189 /// 190 /// @return 191 /// An SBValue that gets filled in with the found variable (if any). 192 //------------------------------------------------------------------ 193 lldb::SBValue 194 FindFirstGlobalVariable (lldb::SBTarget &target, const char *name); 195 196 lldb::SBType 197 FindFirstType (const char* name); 198 199 lldb::SBTypeList 200 FindTypes (const char* type); 201 202 lldb::SBType 203 GetBasicType(lldb::BasicType type); 204 205 //------------------------------------------------------------------ 206 /// Get all types matching \a type_mask from debug info in this 207 /// module. 208 /// 209 /// @param[in] type_mask 210 /// A bitfield that consists of one or more bits logically OR'ed 211 /// together from the lldb::TypeClass enumeration. This allows 212 /// you to request only structure types, or only class, struct 213 /// and union types. Passing in lldb::eTypeClassAny will return 214 /// all types found in the debug information for this module. 215 /// 216 /// @return 217 /// A list of types in this module that match \a type_mask 218 //------------------------------------------------------------------ 219 lldb::SBTypeList 220 GetTypes (uint32_t type_mask = lldb::eTypeClassAny); 221 222 //------------------------------------------------------------------ 223 /// Get the module version numbers. 224 /// 225 /// Many object files have a set of version numbers that describe 226 /// the version of the executable or shared library. Typically there 227 /// are major, minor and build, but there may be more. This function 228 /// will extract the versions from object files if they are available. 229 /// 230 /// If \a versions is NULL, or if \a num_versions is 0, the return 231 /// value will indicate how many version numbers are available in 232 /// this object file. Then a subsequent call can be made to this 233 /// function with a value of \a versions and \a num_versions that 234 /// has enough storage to store some or all version numbers. 235 /// 236 /// @param[out] versions 237 /// A pointer to an array of uint32_t types that is \a num_versions 238 /// long. If this value is NULL, the return value will indicate 239 /// how many version numbers are required for a subsequent call 240 /// to this function so that all versions can be retrieved. If 241 /// the value is non-NULL, then at most \a num_versions of the 242 /// existing versions numbers will be filled into \a versions. 243 /// If there is no version information available, \a versions 244 /// will be filled with \a num_versions UINT32_MAX values 245 /// and zero will be returned. 246 /// 247 /// @param[in] num_versions 248 /// The maximum number of entries to fill into \a versions. If 249 /// this value is zero, then the return value will indicate 250 /// how many version numbers there are in total so another call 251 /// to this function can be make with adequate storage in 252 /// \a versions to get all of the version numbers. If \a 253 /// num_versions is less than the actual number of version 254 /// numbers in this object file, only \a num_versions will be 255 /// filled into \a versions (if \a versions is non-NULL). 256 /// 257 /// @return 258 /// This function always returns the number of version numbers 259 /// that this object file has regardless of the number of 260 /// version numbers that were copied into \a versions. 261 //------------------------------------------------------------------ 262 uint32_t 263 GetVersion (uint32_t *versions, 264 uint32_t num_versions); 265 266 private: 267 friend class SBAddress; 268 friend class SBFrame; 269 friend class SBSection; 270 friend class SBSymbolContext; 271 friend class SBTarget; 272 273 explicit SBModule (const lldb::ModuleSP& module_sp); 274 275 ModuleSP 276 GetSP () const; 277 278 void 279 SetSP (const ModuleSP &module_sp); 280 281 lldb::ModuleSP m_opaque_sp; 282 }; 283 284 285 } // namespace lldb 286 287 #endif // LLDB_SBModule_h_ 288