Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 1 | //===-- SWIG Interface for SBModule -----------------------------*- 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 | namespace lldb { |
| 11 | |
| 12 | %feature("docstring", |
| 13 | "Represents an executable image and its associated object and symbol files. |
| 14 | |
| 15 | The module is designed to be able to select a single slice of an |
| 16 | executable image as it would appear on disk and during program |
| 17 | execution. |
| 18 | |
| 19 | You can retrieve SBModule from SBSymbolContext, which in turn is available |
| 20 | from SBFrame. |
| 21 | |
| 22 | SBModule supports symbol iteration, for example, |
| 23 | |
| 24 | for symbol in module: |
| 25 | name = symbol.GetName() |
| 26 | saddr = symbol.GetStartAddress() |
| 27 | eaddr = symbol.GetEndAddress() |
| 28 | |
| 29 | and rich comparion methods which allow the API program to use, |
| 30 | |
| 31 | if thisModule == thatModule: |
| 32 | print 'This module is the same as that module' |
| 33 | |
Johnny Chen | dc0cbd1 | 2011-09-24 04:51:43 +0000 | [diff] [blame] | 34 | to test module equality. A module also contains object file sections, namely |
Johnny Chen | bf338e6 | 2011-09-30 00:42:49 +0000 | [diff] [blame] | 35 | SBSection. SBModule supports section iteration through section_iter(), for |
| 36 | example, |
| 37 | |
| 38 | print 'Number of sections: %d' % module.GetNumSections() |
| 39 | for sec in module.section_iter(): |
| 40 | print sec |
| 41 | |
| 42 | And to iterate the symbols within a SBSection, use symbol_in_section_iter(), |
| 43 | |
| 44 | # Iterates the text section and prints each symbols within each sub-section. |
| 45 | for subsec in text_sec: |
| 46 | print INDENT + repr(subsec) |
| 47 | for sym in exe_module.symbol_in_section_iter(subsec): |
| 48 | print INDENT2 + repr(sym) |
| 49 | print INDENT2 + 'symbol type: %s' % symbol_type_to_str(sym.GetType()) |
| 50 | |
Johnny Chen | 5cac6a5 | 2011-10-01 01:19:45 +0000 | [diff] [blame] | 51 | produces this following output: |
Johnny Chen | bf338e6 | 2011-09-30 00:42:49 +0000 | [diff] [blame] | 52 | |
| 53 | [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text |
| 54 | id = {0x00000004}, name = 'mask_access(MaskAction, unsigned int)', range = [0x00000001000017c0-0x0000000100001870) |
| 55 | symbol type: code |
| 56 | id = {0x00000008}, name = 'thread_func(void*)', range = [0x0000000100001870-0x00000001000019b0) |
| 57 | symbol type: code |
| 58 | id = {0x0000000c}, name = 'main', range = [0x00000001000019b0-0x0000000100001d5c) |
| 59 | symbol type: code |
| 60 | id = {0x00000023}, name = 'start', address = 0x0000000100001780 |
| 61 | symbol type: code |
| 62 | [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs |
| 63 | id = {0x00000024}, name = '__stack_chk_fail', range = [0x0000000100001d5c-0x0000000100001d62) |
| 64 | symbol type: trampoline |
| 65 | id = {0x00000028}, name = 'exit', range = [0x0000000100001d62-0x0000000100001d68) |
| 66 | symbol type: trampoline |
| 67 | id = {0x00000029}, name = 'fflush', range = [0x0000000100001d68-0x0000000100001d6e) |
| 68 | symbol type: trampoline |
| 69 | id = {0x0000002a}, name = 'fgets', range = [0x0000000100001d6e-0x0000000100001d74) |
| 70 | symbol type: trampoline |
| 71 | id = {0x0000002b}, name = 'printf', range = [0x0000000100001d74-0x0000000100001d7a) |
| 72 | symbol type: trampoline |
| 73 | id = {0x0000002c}, name = 'pthread_create', range = [0x0000000100001d7a-0x0000000100001d80) |
| 74 | symbol type: trampoline |
| 75 | id = {0x0000002d}, name = 'pthread_join', range = [0x0000000100001d80-0x0000000100001d86) |
| 76 | symbol type: trampoline |
| 77 | id = {0x0000002e}, name = 'pthread_mutex_lock', range = [0x0000000100001d86-0x0000000100001d8c) |
| 78 | symbol type: trampoline |
| 79 | id = {0x0000002f}, name = 'pthread_mutex_unlock', range = [0x0000000100001d8c-0x0000000100001d92) |
| 80 | symbol type: trampoline |
| 81 | id = {0x00000030}, name = 'rand', range = [0x0000000100001d92-0x0000000100001d98) |
| 82 | symbol type: trampoline |
| 83 | id = {0x00000031}, name = 'strtoul', range = [0x0000000100001d98-0x0000000100001d9e) |
| 84 | symbol type: trampoline |
| 85 | id = {0x00000032}, name = 'usleep', range = [0x0000000100001d9e-0x0000000100001da4) |
| 86 | symbol type: trampoline |
| 87 | [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper |
| 88 | [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring |
| 89 | [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info |
| 90 | [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame |
| 91 | " |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 92 | ) SBModule; |
| 93 | class SBModule |
| 94 | { |
| 95 | public: |
| 96 | |
| 97 | SBModule (); |
| 98 | |
| 99 | SBModule (const SBModule &rhs); |
| 100 | |
Greg Clayton | b5a8f14 | 2012-02-05 02:38:54 +0000 | [diff] [blame] | 101 | SBModule (lldb::SBProcess &process, |
| 102 | lldb::addr_t header_addr); |
| 103 | |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 104 | ~SBModule (); |
| 105 | |
| 106 | bool |
| 107 | IsValid () const; |
| 108 | |
Jim Ingham | e0bd571 | 2011-12-19 20:39:44 +0000 | [diff] [blame] | 109 | void |
| 110 | Clear(); |
| 111 | |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 112 | %feature("docstring", " |
| 113 | //------------------------------------------------------------------ |
| 114 | /// Get const accessor for the module file specification. |
| 115 | /// |
| 116 | /// This function returns the file for the module on the host system |
| 117 | /// that is running LLDB. This can differ from the path on the |
| 118 | /// platform since we might be doing remote debugging. |
| 119 | /// |
| 120 | /// @return |
| 121 | /// A const reference to the file specification object. |
| 122 | //------------------------------------------------------------------ |
| 123 | ") GetFileSpec; |
| 124 | lldb::SBFileSpec |
| 125 | GetFileSpec () const; |
| 126 | |
| 127 | %feature("docstring", " |
| 128 | //------------------------------------------------------------------ |
| 129 | /// Get accessor for the module platform file specification. |
| 130 | /// |
| 131 | /// Platform file refers to the path of the module as it is known on |
| 132 | /// the remote system on which it is being debugged. For local |
| 133 | /// debugging this is always the same as Module::GetFileSpec(). But |
| 134 | /// remote debugging might mention a file '/usr/lib/liba.dylib' |
| 135 | /// which might be locally downloaded and cached. In this case the |
| 136 | /// platform file could be something like: |
| 137 | /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib' |
| 138 | /// The file could also be cached in a local developer kit directory. |
| 139 | /// |
| 140 | /// @return |
| 141 | /// A const reference to the file specification object. |
| 142 | //------------------------------------------------------------------ |
| 143 | ") GetPlatformFileSpec; |
| 144 | lldb::SBFileSpec |
| 145 | GetPlatformFileSpec () const; |
| 146 | |
| 147 | bool |
| 148 | SetPlatformFileSpec (const lldb::SBFileSpec &platform_file); |
| 149 | |
| 150 | %feature("docstring", "Returns the UUID of the module as a Python string." |
| 151 | ) GetUUIDString; |
| 152 | const char * |
| 153 | GetUUIDString () const; |
| 154 | |
Greg Clayton | 3e8c25f | 2011-09-24 00:52:29 +0000 | [diff] [blame] | 155 | lldb::SBSection |
| 156 | FindSection (const char *sect_name); |
| 157 | |
| 158 | lldb::SBAddress |
| 159 | ResolveFileAddress (lldb::addr_t vm_addr); |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 160 | |
| 161 | lldb::SBSymbolContext |
| 162 | ResolveSymbolContextForAddress (const lldb::SBAddress& addr, |
| 163 | uint32_t resolve_scope); |
| 164 | |
| 165 | bool |
| 166 | GetDescription (lldb::SBStream &description); |
| 167 | |
Johnny Chen | 1dbf2a8 | 2012-03-16 21:55:42 +0000 | [diff] [blame] | 168 | uint32_t |
| 169 | GetNumCompileUnits(); |
| 170 | |
| 171 | lldb::SBCompileUnit |
| 172 | GetCompileUnitAtIndex (uint32_t); |
| 173 | |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 174 | size_t |
| 175 | GetNumSymbols (); |
| 176 | |
| 177 | lldb::SBSymbol |
| 178 | GetSymbolAtIndex (size_t idx); |
| 179 | |
Greg Clayton | 3e8c25f | 2011-09-24 00:52:29 +0000 | [diff] [blame] | 180 | size_t |
| 181 | GetNumSections (); |
| 182 | |
| 183 | lldb::SBSection |
| 184 | GetSectionAtIndex (size_t idx); |
| 185 | |
| 186 | |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 187 | %feature("docstring", " |
| 188 | //------------------------------------------------------------------ |
| 189 | /// Find functions by name. |
| 190 | /// |
| 191 | /// @param[in] name |
| 192 | /// The name of the function we are looking for. |
| 193 | /// |
| 194 | /// @param[in] name_type_mask |
| 195 | /// A logical OR of one or more FunctionNameType enum bits that |
| 196 | /// indicate what kind of names should be used when doing the |
| 197 | /// lookup. Bits include fully qualified names, base names, |
| 198 | /// C++ methods, or ObjC selectors. |
| 199 | /// See FunctionNameType for more details. |
| 200 | /// |
Greg Clayton | 7dd5c51 | 2012-02-06 01:44:54 +0000 | [diff] [blame] | 201 | /// @return |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 202 | /// A symbol context list that gets filled in with all of the |
| 203 | /// matches. |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 204 | //------------------------------------------------------------------ |
| 205 | ") FindFunctions; |
Greg Clayton | 7dd5c51 | 2012-02-06 01:44:54 +0000 | [diff] [blame] | 206 | lldb::SBSymbolContextList |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 207 | FindFunctions (const char *name, |
Greg Clayton | 7dd5c51 | 2012-02-06 01:44:54 +0000 | [diff] [blame] | 208 | uint32_t name_type_mask = lldb::eFunctionNameTypeAny); |
Enrico Granata | 979e20d | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 209 | |
| 210 | lldb::SBType |
| 211 | FindFirstType (const char* name); |
| 212 | |
| 213 | lldb::SBTypeList |
| 214 | FindTypes (const char* type); |
| 215 | |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 216 | |
| 217 | %feature("docstring", " |
| 218 | //------------------------------------------------------------------ |
| 219 | /// Find global and static variables by name. |
| 220 | /// |
| 221 | /// @param[in] target |
| 222 | /// A valid SBTarget instance representing the debuggee. |
| 223 | /// |
| 224 | /// @param[in] name |
| 225 | /// The name of the global or static variable we are looking |
| 226 | /// for. |
| 227 | /// |
| 228 | /// @param[in] max_matches |
| 229 | /// Allow the number of matches to be limited to \a max_matches. |
| 230 | /// |
| 231 | /// @return |
| 232 | /// A list of matched variables in an SBValueList. |
| 233 | //------------------------------------------------------------------ |
| 234 | ") FindGlobalVariables; |
| 235 | lldb::SBValueList |
| 236 | FindGlobalVariables (lldb::SBTarget &target, |
| 237 | const char *name, |
| 238 | uint32_t max_matches); |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 239 | |
| 240 | lldb::ByteOrder |
| 241 | GetByteOrder (); |
| 242 | |
| 243 | uint32_t |
| 244 | GetAddressByteSize(); |
| 245 | |
| 246 | const char * |
| 247 | GetTriple (); |
Greg Clayton | 49f4bf2 | 2012-02-22 19:41:02 +0000 | [diff] [blame] | 248 | |
| 249 | uint32_t |
| 250 | GetVersion (uint32_t *versions, |
| 251 | uint32_t num_versions); |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 252 | |
| 253 | %pythoncode %{ |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 254 | class symbols_access(object): |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 255 | re_compile_type = type(re.compile('.')) |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 256 | '''A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.''' |
| 257 | def __init__(self, sbmodule): |
| 258 | self.sbmodule = sbmodule |
| 259 | |
| 260 | def __len__(self): |
| 261 | if self.sbmodule: |
Filipe Cabecinhas | 3cae38b | 2012-05-11 20:39:42 +0000 | [diff] [blame] | 262 | return int(self.sbmodule.GetNumSymbols()) |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 263 | return 0 |
| 264 | |
| 265 | def __getitem__(self, key): |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 266 | count = len(self) |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 267 | if type(key) is int: |
| 268 | if key < count: |
| 269 | return self.sbmodule.GetSymbolAtIndex(key) |
| 270 | elif type(key) is str: |
| 271 | matches = [] |
| 272 | for idx in range(count): |
| 273 | symbol = self.sbmodule.GetSymbolAtIndex(idx) |
| 274 | if symbol.name == key or symbol.mangled == key: |
| 275 | matches.append(symbol) |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 276 | return matches |
| 277 | elif isinstance(key, self.re_compile_type): |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 278 | matches = [] |
| 279 | for idx in range(count): |
| 280 | symbol = self.sbmodule.GetSymbolAtIndex(idx) |
| 281 | added = False |
| 282 | name = symbol.name |
| 283 | if name: |
| 284 | re_match = key.search(name) |
| 285 | if re_match: |
| 286 | matches.append(symbol) |
| 287 | added = True |
| 288 | if not added: |
| 289 | mangled = symbol.mangled |
| 290 | if mangled: |
| 291 | re_match = key.search(mangled) |
| 292 | if re_match: |
| 293 | matches.append(symbol) |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 294 | return matches |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 295 | else: |
| 296 | print "error: unsupported item type: %s" % type(key) |
| 297 | return None |
| 298 | |
| 299 | def get_symbols_access_object(self): |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 300 | '''An accessor function that returns a symbols_access() object which allows lazy symbol access from a lldb.SBModule object.''' |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 301 | return self.symbols_access (self) |
| 302 | |
| 303 | def get_symbols_array(self): |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 304 | '''An accessor function that returns a list() that contains all symbols in a lldb.SBModule object.''' |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 305 | symbols = [] |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 306 | for idx in range(self.num_symbols): |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 307 | symbols.append(self.GetSymbolAtIndex(idx)) |
| 308 | return symbols |
| 309 | |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 310 | class sections_access(object): |
| 311 | re_compile_type = type(re.compile('.')) |
| 312 | '''A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.''' |
| 313 | def __init__(self, sbmodule): |
| 314 | self.sbmodule = sbmodule |
| 315 | |
| 316 | def __len__(self): |
| 317 | if self.sbmodule: |
Filipe Cabecinhas | 3cae38b | 2012-05-11 20:39:42 +0000 | [diff] [blame] | 318 | return int(self.sbmodule.GetNumSections()) |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 319 | return 0 |
| 320 | |
| 321 | def __getitem__(self, key): |
| 322 | count = len(self) |
| 323 | if type(key) is int: |
| 324 | if key < count: |
| 325 | return self.sbmodule.GetSectionAtIndex(key) |
| 326 | elif type(key) is str: |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 327 | for idx in range(count): |
| 328 | section = self.sbmodule.GetSectionAtIndex(idx) |
| 329 | if section.name == key: |
Greg Clayton | 39f54ea | 2012-02-04 02:58:17 +0000 | [diff] [blame] | 330 | return section |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 331 | elif isinstance(key, self.re_compile_type): |
| 332 | matches = [] |
| 333 | for idx in range(count): |
| 334 | section = self.sbmodule.GetSectionAtIndex(idx) |
| 335 | name = section.name |
| 336 | if name: |
| 337 | re_match = key.search(name) |
| 338 | if re_match: |
| 339 | matches.append(section) |
| 340 | return matches |
| 341 | else: |
| 342 | print "error: unsupported item type: %s" % type(key) |
| 343 | return None |
| 344 | |
| 345 | def get_sections_access_object(self): |
| 346 | '''An accessor function that returns a sections_access() object which allows lazy section array access.''' |
| 347 | return self.sections_access (self) |
| 348 | |
| 349 | def get_sections_array(self): |
| 350 | '''An accessor function that returns an array object that contains all sections in this module object.''' |
| 351 | if not hasattr(self, 'sections'): |
| 352 | self.sections = [] |
| 353 | for idx in range(self.num_sections): |
| 354 | self.sections.append(self.GetSectionAtIndex(idx)) |
| 355 | return self.sections |
| 356 | |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 357 | __swig_getmethods__["symbols"] = get_symbols_array |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 358 | if _newclass: symbols = property(get_symbols_array, None, doc='''A read only property that returns a list() of lldb.SBSymbol objects contained in this module.''') |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 359 | |
| 360 | __swig_getmethods__["symbol"] = get_symbols_access_object |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 361 | if _newclass: symbol = property(get_symbols_access_object, None, doc='''A read only property that can be used to access symbols by index ("symbol = module.symbol[0]"), name ("symbols = module.symbol['main']"), or using a regular expression ("symbols = module.symbol[re.compile(...)]"). The return value is a single lldb.SBSymbol object for array access, and a list() of lldb.SBSymbol objects for name and regular expression access''') |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 362 | |
| 363 | __swig_getmethods__["sections"] = get_sections_array |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 364 | if _newclass: sections = property(get_sections_array, None, doc='''A read only property that returns a list() of lldb.SBSection objects contained in this module.''') |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 365 | |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 366 | __swig_getmethods__["section"] = get_sections_access_object |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 367 | if _newclass: section = property(get_sections_access_object, None, doc='''A read only property that can be used to access symbols by index ("section = module.section[0]"), name ("sections = module.section[\'main\']"), or using a regular expression ("sections = module.section[re.compile(...)]"). The return value is a single lldb.SBSection object for array access, and a list() of lldb.SBSection objects for name and regular expression access''') |
Greg Clayton | b6a5ba6 | 2012-02-03 03:22:53 +0000 | [diff] [blame] | 368 | |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 369 | def get_uuid(self): |
| 370 | return uuid.UUID (self.GetUUIDString()) |
| 371 | |
| 372 | __swig_getmethods__["uuid"] = get_uuid |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 373 | if _newclass: uuid = property(get_uuid, None, doc='''A read only property that returns a standard python uuid.UUID object that represents the UUID of this module.''') |
Greg Clayton | b302dff | 2012-02-01 08:09:32 +0000 | [diff] [blame] | 374 | |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 375 | __swig_getmethods__["file"] = GetFileSpec |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 376 | if _newclass: file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this object file for this module as it is represented where it is being debugged.''') |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 377 | |
| 378 | __swig_getmethods__["platform_file"] = GetPlatformFileSpec |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 379 | if _newclass: platform_file = property(GetPlatformFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this object file for this module as it is represented on the current host system.''') |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 380 | |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 381 | __swig_getmethods__["byte_order"] = GetByteOrder |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 382 | if _newclass: byte_order = property(GetByteOrder, None, doc='''A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this module.''') |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 383 | |
| 384 | __swig_getmethods__["addr_size"] = GetAddressByteSize |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 385 | if _newclass: addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this module.''') |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 386 | |
| 387 | __swig_getmethods__["triple"] = GetTriple |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 388 | if _newclass: triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this module.''') |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 389 | |
| 390 | __swig_getmethods__["num_symbols"] = GetNumSymbols |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 391 | if _newclass: num_symbols = property(GetNumSymbols, None, doc='''A read only property that returns number of symbols in the module symbol table as an integer.''') |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 392 | |
| 393 | __swig_getmethods__["num_sections"] = GetNumSections |
Greg Clayton | 2a94be1 | 2012-06-29 22:00:42 +0000 | [diff] [blame] | 394 | if _newclass: num_sections = property(GetNumSections, None, doc='''A read only property that returns number of sections in the module as an integer.''') |
Greg Clayton | 1b92520 | 2012-01-29 06:07:39 +0000 | [diff] [blame] | 395 | |
| 396 | %} |
| 397 | |
Johnny Chen | fb35e2a | 2011-07-18 23:11:07 +0000 | [diff] [blame] | 398 | }; |
| 399 | |
| 400 | } // namespace lldb |