Module.h revision 02e210cad27e36108bef493b798c2c1eb3b04cb8
1//===-- Module.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 liblldb_Module_h_ 11#define liblldb_Module_h_ 12 13#include "lldb/Core/ArchSpec.h" 14#include "lldb/Core/Section.h" 15#include "lldb/Core/UUID.h" 16#include "lldb/Symbol/ObjectFile.h" 17#include "lldb/Host/Mutex.h" 18#include "lldb/Host/TimeValue.h" 19#include "lldb/Symbol/ClangASTContext.h" 20#include "lldb/Symbol/CompileUnit.h" 21#include "lldb/Symbol/SymbolContext.h" 22#include "lldb/Symbol/Symtab.h" 23#include "lldb/Symbol/TypeList.h" 24 25//---------------------------------------------------------------------- 26/// @class Module Module.h "lldb/Core/Module.h" 27/// @brief A class that describes an executable image and its associated 28/// object and symbol files. 29/// 30/// The module is designed to be able to select a single slice of an 31/// executable image as it would appear on disk and during program 32/// execution. 33/// 34/// Modules control when and if information is parsed according to which 35/// accessors are called. For example the object file (ObjectFile) 36/// representation will only be parsed if the object file is requested 37/// using the Module::GetObjectFile() is called. The debug symbols 38/// will only be parsed if the symbol vendor (SymbolVendor) is 39/// requested using the Module::GetSymbolVendor() is called. 40/// 41/// The module will parse more detailed information as more queries are 42/// made. 43//---------------------------------------------------------------------- 44namespace lldb_private { 45 46class Module : 47 public ReferenceCountedBaseVirtual<Module>, 48 public SymbolContextScope 49{ 50public: 51 friend class ModuleList; 52 friend bool ObjectFile::SetModulesArchitecture (const ArchSpec &new_arch); 53 54 // Static functions that can track the lifetime of moodule objects. 55 // This is handy because we might have Module objects that are in 56 // shared pointers that aren't in the global module list (from 57 // ModuleList). If this is the case we need to know about it. 58 // The modules in the global list maintained by these functions 59 // can be viewed using the "target modules list" command using the 60 // "--global" (-g for short). 61 static size_t 62 GetNumberAllocatedModules (); 63 64 static Module * 65 GetAllocatedModuleAtIndex (size_t idx); 66 67 static Mutex & 68 GetAllocationModuleCollectionMutex(); 69 70 //------------------------------------------------------------------ 71 /// Construct with file specification and architecture. 72 /// 73 /// Clients that wish to share modules with other targets should 74 /// use ModuleList::GetSharedModule(). 75 /// 76 /// @param[in] file_spec 77 /// The file specification for the on disk repesentation of 78 /// this executable image. 79 /// 80 /// @param[in] arch 81 /// The architecture to set as the current architecture in 82 /// this module. 83 /// 84 /// @param[in] object_name 85 /// The name of an object in a module used to extract a module 86 /// within a module (.a files and modules that contain multiple 87 /// architectures). 88 /// 89 /// @param[in] object_offset 90 /// The offset within an existing module used to extract a 91 /// module within a module (.a files and modules that contain 92 /// multiple architectures). 93 //------------------------------------------------------------------ 94 Module (const FileSpec& file_spec, 95 const ArchSpec& arch, 96 const ConstString *object_name = NULL, 97 off_t object_offset = 0); 98 99 //------------------------------------------------------------------ 100 /// Destructor. 101 //------------------------------------------------------------------ 102 virtual 103 ~Module (); 104 105 //------------------------------------------------------------------ 106 /// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*) 107 /// 108 /// @see SymbolContextScope 109 //------------------------------------------------------------------ 110 virtual void 111 CalculateSymbolContext (SymbolContext* sc); 112 113 virtual Module * 114 CalculateSymbolContextModule (); 115 116 void 117 GetDescription (Stream *s); 118 119 //------------------------------------------------------------------ 120 /// Dump a description of this object to a Stream. 121 /// 122 /// Dump a description of the contents of this object to the 123 /// supplied stream \a s. The dumped content will be only what has 124 /// been loaded or parsed up to this point at which this function 125 /// is called, so this is a good way to see what has been parsed 126 /// in a module. 127 /// 128 /// @param[in] s 129 /// The stream to which to dump the object descripton. 130 //------------------------------------------------------------------ 131 void 132 Dump (Stream *s); 133 134 //------------------------------------------------------------------ 135 /// @copydoc SymbolContextScope::DumpSymbolContext(Stream*) 136 /// 137 /// @see SymbolContextScope 138 //------------------------------------------------------------------ 139 virtual void 140 DumpSymbolContext (Stream *s); 141 142 //------------------------------------------------------------------ 143 /// Find a symbol in the object files symbol table. 144 /// 145 /// @param[in] name 146 /// The name of the symbol that we are looking for. 147 /// 148 /// @param[in] symbol_type 149 /// If set to eSymbolTypeAny, find a symbol of any type that 150 /// has a name that matches \a name. If set to any other valid 151 /// SymbolType enumeration value, then search only for 152 /// symbols that match \a symbol_type. 153 /// 154 /// @return 155 /// Returns a valid symbol pointer if a symbol was found, 156 /// NULL otherwise. 157 //------------------------------------------------------------------ 158 const Symbol * 159 FindFirstSymbolWithNameAndType (const ConstString &name, 160 lldb::SymbolType symbol_type = lldb::eSymbolTypeAny); 161 162 size_t 163 FindSymbolsWithNameAndType (const ConstString &name, 164 lldb::SymbolType symbol_type, 165 SymbolContextList &sc_list); 166 167 size_t 168 FindSymbolsMatchingRegExAndType (const RegularExpression ®ex, 169 lldb::SymbolType symbol_type, 170 SymbolContextList &sc_list); 171 172 //------------------------------------------------------------------ 173 /// Find compile units by partial or full path. 174 /// 175 /// Finds all compile units that match \a path in all of the modules 176 /// and returns the results in \a sc_list. 177 /// 178 /// @param[in] path 179 /// The name of the function we are looking for. 180 /// 181 /// @param[in] append 182 /// If \b true, then append any compile units that were found 183 /// to \a sc_list. If \b false, then the \a sc_list is cleared 184 /// and the contents of \a sc_list are replaced. 185 /// 186 /// @param[out] sc_list 187 /// A symbol context list that gets filled in with all of the 188 /// matches. 189 /// 190 /// @return 191 /// The number of matches added to \a sc_list. 192 //------------------------------------------------------------------ 193 uint32_t 194 FindCompileUnits (const FileSpec &path, 195 bool append, 196 SymbolContextList &sc_list); 197 198 199 //------------------------------------------------------------------ 200 /// Find functions by name. 201 /// 202 /// @param[in] name 203 /// The name of the compile unit we are looking for. 204 /// 205 /// @param[in] name_type_mask 206 /// A bit mask of bits that indicate what kind of names should 207 /// be used when doing the lookup. Bits include fully qualified 208 /// names, base names, C++ methods, or ObjC selectors. 209 /// See FunctionNameType for more details. 210 /// 211 /// @param[in] append 212 /// If \b true, any matches will be appended to \a sc_list, else 213 /// matches replace the contents of \a sc_list. 214 /// 215 /// @param[out] sc_list 216 /// A symbol context list that gets filled in with all of the 217 /// matches. 218 /// 219 /// @return 220 /// The number of matches added to \a sc_list. 221 //------------------------------------------------------------------ 222 uint32_t 223 FindFunctions (const ConstString &name, 224 uint32_t name_type_mask, 225 bool symbols_ok, 226 bool append, 227 SymbolContextList& sc_list); 228 229 //------------------------------------------------------------------ 230 /// Find functions by name. 231 /// 232 /// @param[in] regex 233 /// A regular expression to use when matching the name. 234 /// 235 /// @param[in] append 236 /// If \b true, any matches will be appended to \a sc_list, else 237 /// matches replace the contents of \a sc_list. 238 /// 239 /// @param[out] sc_list 240 /// A symbol context list that gets filled in with all of the 241 /// matches. 242 /// 243 /// @return 244 /// The number of matches added to \a sc_list. 245 //------------------------------------------------------------------ 246 uint32_t 247 FindFunctions (const RegularExpression& regex, 248 bool symbols_ok, 249 bool append, 250 SymbolContextList& sc_list); 251 252 //------------------------------------------------------------------ 253 /// Find global and static variables by name. 254 /// 255 /// @param[in] name 256 /// The name of the global or static variable we are looking 257 /// for. 258 /// 259 /// @param[in] append 260 /// If \b true, any matches will be appended to \a 261 /// variable_list, else matches replace the contents of 262 /// \a variable_list. 263 /// 264 /// @param[in] max_matches 265 /// Allow the number of matches to be limited to \a 266 /// max_matches. Specify UINT32_MAX to get all possible matches. 267 /// 268 /// @param[in] variable_list 269 /// A list of variables that gets the matches appended to (if 270 /// \a append it \b true), or replace (if \a append is \b false). 271 /// 272 /// @return 273 /// The number of matches added to \a variable_list. 274 //------------------------------------------------------------------ 275 uint32_t 276 FindGlobalVariables (const ConstString &name, 277 bool append, 278 uint32_t max_matches, 279 VariableList& variable_list); 280 281 //------------------------------------------------------------------ 282 /// Find global and static variables by regular exression. 283 /// 284 /// @param[in] regex 285 /// A regular expression to use when matching the name. 286 /// 287 /// @param[in] append 288 /// If \b true, any matches will be appended to \a 289 /// variable_list, else matches replace the contents of 290 /// \a variable_list. 291 /// 292 /// @param[in] max_matches 293 /// Allow the number of matches to be limited to \a 294 /// max_matches. Specify UINT32_MAX to get all possible matches. 295 /// 296 /// @param[in] variable_list 297 /// A list of variables that gets the matches appended to (if 298 /// \a append it \b true), or replace (if \a append is \b false). 299 /// 300 /// @return 301 /// The number of matches added to \a variable_list. 302 //------------------------------------------------------------------ 303 uint32_t 304 FindGlobalVariables (const RegularExpression& regex, 305 bool append, 306 uint32_t max_matches, 307 VariableList& variable_list); 308 309 //------------------------------------------------------------------ 310 /// Find types by name. 311 /// 312 /// @param[in] sc 313 /// A symbol context that scopes where to extract a type list 314 /// from. 315 /// 316 /// @param[in] name 317 /// The name of the type we are looking for. 318 /// 319 /// @param[in] append 320 /// If \b true, any matches will be appended to \a 321 /// variable_list, else matches replace the contents of 322 /// \a variable_list. 323 /// 324 /// @param[in] max_matches 325 /// Allow the number of matches to be limited to \a 326 /// max_matches. Specify UINT32_MAX to get all possible matches. 327 /// 328 /// @param[in] encoding 329 /// Limit the search to specific types, or get all types if 330 /// set to Type::invalid. 331 /// 332 /// @param[in] udt_name 333 /// If the encoding is a user defined type, specify the name 334 /// of the user defined type ("struct", "union", "class", etc). 335 /// 336 /// @param[out] type_list 337 /// A type list gets populated with any matches. 338 /// 339 /// @return 340 /// The number of matches added to \a type_list. 341 //------------------------------------------------------------------ 342 uint32_t 343 FindTypes (const SymbolContext& sc, 344 const ConstString &name, 345 bool append, 346 uint32_t max_matches, 347 TypeList& types); 348 349 //------------------------------------------------------------------ 350 /// Get const accessor for the module architecture. 351 /// 352 /// @return 353 /// A const reference to the architecture object. 354 //------------------------------------------------------------------ 355 const ArchSpec& 356 GetArchitecture () const; 357 358 //------------------------------------------------------------------ 359 /// Get const accessor for the module file specification. 360 /// 361 /// This function returns the file for the module on the host system 362 /// that is running LLDB. This can differ from the path on the 363 /// platform since we might be doing remote debugging. 364 /// 365 /// @return 366 /// A const reference to the file specification object. 367 //------------------------------------------------------------------ 368 const FileSpec & 369 GetFileSpec () const 370 { 371 return m_file; 372 } 373 374 //------------------------------------------------------------------ 375 /// Get accessor for the module platform file specification. 376 /// 377 /// Platform file refers to the path of the module as it is known on 378 /// the remote system on which it is being debugged. For local 379 /// debugging this is always the same as Module::GetFileSpec(). But 380 /// remote debugging might mention a file "/usr/lib/liba.dylib" 381 /// which might be locally downloaded and cached. In this case the 382 /// platform file could be something like: 383 /// "/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib" 384 /// The file could also be cached in a local developer kit directory. 385 /// 386 /// @return 387 /// A const reference to the file specification object. 388 //------------------------------------------------------------------ 389 const FileSpec & 390 GetPlatformFileSpec () const 391 { 392 if (m_platform_file) 393 return m_platform_file; 394 return m_file; 395 } 396 397 void 398 SetPlatformFileSpec (const FileSpec &file) 399 { 400 m_platform_file = file; 401 } 402 403 const TimeValue & 404 GetModificationTime () const; 405 406 //------------------------------------------------------------------ 407 /// Tells whether this module is capable of being the main executable 408 /// for a process. 409 /// 410 /// @return 411 /// \b true if it is, \b false otherwise. 412 //------------------------------------------------------------------ 413 bool 414 IsExecutable (); 415 416 //------------------------------------------------------------------ 417 /// Tells whether this module has been loaded in the target passed in. 418 /// This call doesn't distinguish between whether the module is loaded 419 /// by the dynamic loader, or by a "target module add" type call. 420 /// 421 /// @param[in] target 422 /// The target to check whether this is loaded in. 423 /// 424 /// @return 425 /// \b true if it is, \b false otherwise. 426 //------------------------------------------------------------------ 427 bool 428 IsLoadedInTarget (Target *target); 429 430 //------------------------------------------------------------------ 431 /// Get the number of compile units for this module. 432 /// 433 /// @return 434 /// The number of compile units that the symbol vendor plug-in 435 /// finds. 436 //------------------------------------------------------------------ 437 uint32_t 438 GetNumCompileUnits(); 439 440 lldb::CompUnitSP 441 GetCompileUnitAtIndex (uint32_t); 442 443 const ConstString & 444 GetObjectName() const; 445 446 uint64_t 447 GetObjectOffset() const 448 { 449 return m_object_offset; 450 } 451 452 //------------------------------------------------------------------ 453 /// Get the object file representation for the current architecture. 454 /// 455 /// If the object file has not been located or parsed yet, this 456 /// function will find the best ObjectFile plug-in that can parse 457 /// Module::m_file. 458 /// 459 /// @return 460 /// If Module::m_file does not exist, or no plug-in was found 461 /// that can parse the file, or the object file doesn't contain 462 /// the current architecture in Module::m_arch, NULL will be 463 /// returned, else a valid object file interface will be 464 /// returned. The returned pointer is owned by this object and 465 /// remains valid as long as the object is around. 466 //------------------------------------------------------------------ 467 ObjectFile * 468 GetObjectFile (); 469 470 //------------------------------------------------------------------ 471 /// Get the symbol vendor interface for the current architecture. 472 /// 473 /// If the symbol vendor file has not been located yet, this 474 /// function will find the best SymbolVendor plug-in that can 475 /// use the current object file. 476 /// 477 /// @return 478 /// If this module does not have a valid object file, or no 479 /// plug-in can be found that can use the object file, NULL will 480 /// be returned, else a valid symbol vendor plug-in interface 481 /// will be returned. The returned pointer is owned by this 482 /// object and remains valid as long as the object is around. 483 //------------------------------------------------------------------ 484 SymbolVendor* 485 GetSymbolVendor(bool can_create = true); 486 487 //------------------------------------------------------------------ 488 /// Get accessor the type list for this module. 489 /// 490 /// @return 491 /// A valid type list pointer, or NULL if there is no valid 492 /// symbol vendor for this module. 493 //------------------------------------------------------------------ 494 TypeList* 495 GetTypeList (); 496 497 //------------------------------------------------------------------ 498 /// Get a pointer to the UUID value contained in this object. 499 /// 500 /// If the executable image file doesn't not have a UUID value built 501 /// into the file format, an MD5 checksum of the entire file, or 502 /// slice of the file for the current architecture should be used. 503 /// 504 /// @return 505 /// A const pointer to the internal copy of the UUID value in 506 /// this module if this module has a valid UUID value, NULL 507 /// otherwise. 508 //------------------------------------------------------------------ 509 const lldb_private::UUID & 510 GetUUID (); 511 512 //------------------------------------------------------------------ 513 /// A debugging function that will cause everything in a module to 514 /// be parsed. 515 /// 516 /// All compile units will be pasred, along with all globals and 517 /// static variables and all functions for those compile units. 518 /// All types, scopes, local variables, static variables, global 519 /// variables, and line tables will be parsed. This can be used 520 /// prior to dumping a module to see a complete list of the 521 /// resuling debug information that gets parsed, or as a debug 522 /// function to ensure that the module can consume all of the 523 /// debug data the symbol vendor provides. 524 //------------------------------------------------------------------ 525 void 526 ParseAllDebugSymbols(); 527 528 bool 529 ResolveFileAddress (lldb::addr_t vm_addr, Address& so_addr); 530 531 uint32_t 532 ResolveSymbolContextForAddress (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc); 533 534 //------------------------------------------------------------------ 535 /// Resolve items in the symbol context for a given file and line. 536 /// 537 /// Tries to resolve \a file_path and \a line to a list of matching 538 /// symbol contexts. 539 /// 540 /// The line table entries contains addresses that can be used to 541 /// further resolve the values in each match: the function, block, 542 /// symbol. Care should be taken to minimize the amount of 543 /// information that is requested to only what is needed -- 544 /// typically the module, compile unit, line table and line table 545 /// entry are sufficient. 546 /// 547 /// @param[in] file_path 548 /// A path to a source file to match. If \a file_path does not 549 /// specify a directory, then this query will match all files 550 /// whose base filename matches. If \a file_path does specify 551 /// a directory, the fullpath to the file must match. 552 /// 553 /// @param[in] line 554 /// The source line to match, or zero if just the compile unit 555 /// should be resolved. 556 /// 557 /// @param[in] check_inlines 558 /// Check for inline file and line number matches. This option 559 /// should be used sparingly as it will cause all line tables 560 /// for every compile unit to be parsed and searched for 561 /// matching inline file entries. 562 /// 563 /// @param[in] resolve_scope 564 /// The scope that should be resolved (see 565 /// SymbolContext::Scope). 566 /// 567 /// @param[out] sc_list 568 /// A symbol context list that gets matching symbols contexts 569 /// appended to. 570 /// 571 /// @return 572 /// The number of matches that were added to \a sc_list. 573 /// 574 /// @see SymbolContext::Scope 575 //------------------------------------------------------------------ 576 uint32_t 577 ResolveSymbolContextForFilePath (const char *file_path, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list); 578 579 //------------------------------------------------------------------ 580 /// Resolve items in the symbol context for a given file and line. 581 /// 582 /// Tries to resolve \a file_spec and \a line to a list of matching 583 /// symbol contexts. 584 /// 585 /// The line table entries contains addresses that can be used to 586 /// further resolve the values in each match: the function, block, 587 /// symbol. Care should be taken to minimize the amount of 588 /// information that is requested to only what is needed -- 589 /// typically the module, compile unit, line table and line table 590 /// entry are sufficient. 591 /// 592 /// @param[in] file_spec 593 /// A file spec to a source file to match. If \a file_path does 594 /// not specify a directory, then this query will match all 595 /// files whose base filename matches. If \a file_path does 596 /// specify a directory, the fullpath to the file must match. 597 /// 598 /// @param[in] line 599 /// The source line to match, or zero if just the compile unit 600 /// should be resolved. 601 /// 602 /// @param[in] check_inlines 603 /// Check for inline file and line number matches. This option 604 /// should be used sparingly as it will cause all line tables 605 /// for every compile unit to be parsed and searched for 606 /// matching inline file entries. 607 /// 608 /// @param[in] resolve_scope 609 /// The scope that should be resolved (see 610 /// SymbolContext::Scope). 611 /// 612 /// @param[out] sc_list 613 /// A symbol context list that gets filled in with all of the 614 /// matches. 615 /// 616 /// @return 617 /// A integer that contains SymbolContext::Scope bits set for 618 /// each item that was successfully resolved. 619 /// 620 /// @see SymbolContext::Scope 621 //------------------------------------------------------------------ 622 uint32_t 623 ResolveSymbolContextsForFileSpec (const FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list); 624 625 626 void 627 SetFileSpecAndObjectName (const FileSpec &file, 628 const ConstString &object_name); 629 630 bool 631 GetIsDynamicLinkEditor () const 632 { 633 return m_is_dynamic_loader_module; 634 } 635 636 void 637 SetIsDynamicLinkEditor (bool b) 638 { 639 m_is_dynamic_loader_module = b; 640 } 641 642 ClangASTContext & 643 GetClangASTContext (); 644 645protected: 646 //------------------------------------------------------------------ 647 // Member Variables 648 //------------------------------------------------------------------ 649 mutable Mutex m_mutex; ///< A mutex to keep this object happy in multi-threaded environments. 650 TimeValue m_mod_time; ///< The modification time for this module when it was created. 651 ArchSpec m_arch; ///< The architecture for this module. 652 lldb_private::UUID m_uuid; ///< Each module is assumed to have a unique identifier to help match it up to debug symbols. 653 FileSpec m_file; ///< The file representation on disk for this module (if there is one). 654 FileSpec m_platform_file;///< The path to the module on the platform on which it is being debugged 655 ConstString m_object_name; ///< The name an object within this module that is selected, or empty of the module is represented by \a m_file. 656 uint64_t m_object_offset; 657 std::auto_ptr<ObjectFile> m_objfile_ap; ///< A pointer to the object file parser for this module. 658 std::auto_ptr<SymbolVendor> m_symfile_ap; ///< A pointer to the symbol vendor for this module. 659 ClangASTContext m_ast; ///< The AST context for this module. 660 bool m_did_load_objfile:1, 661 m_did_load_symbol_vendor:1, 662 m_did_parse_uuid:1, 663 m_did_init_ast:1, 664 m_is_dynamic_loader_module:1; 665 666 //------------------------------------------------------------------ 667 /// Resolve a file or load virtual address. 668 /// 669 /// Tries to resolve \a vm_addr as a file address (if \a 670 /// vm_addr_is_file_addr is true) or as a load address if \a 671 /// vm_addr_is_file_addr is false) in the symbol vendor. 672 /// \a resolve_scope indicates what clients wish to resolve 673 /// and can be used to limit the scope of what is parsed. 674 /// 675 /// @param[in] vm_addr 676 /// The load virtual address to resolve. 677 /// 678 /// @param[in] vm_addr_is_file_addr 679 /// If \b true, \a vm_addr is a file address, else \a vm_addr 680 /// if a load address. 681 /// 682 /// @param[in] resolve_scope 683 /// The scope that should be resolved (see 684 /// SymbolContext::Scope). 685 /// 686 /// @param[out] so_addr 687 /// The section offset based address that got resolved if 688 /// any bits are returned. 689 /// 690 /// @param[out] sc 691 // The symbol context that has objects filled in. Each bit 692 /// in the \a resolve_scope pertains to a member in the \a sc. 693 /// 694 /// @return 695 /// A integer that contains SymbolContext::Scope bits set for 696 /// each item that was successfully resolved. 697 /// 698 /// @see SymbolContext::Scope 699 //------------------------------------------------------------------ 700 uint32_t 701 ResolveSymbolContextForAddress (lldb::addr_t vm_addr, 702 bool vm_addr_is_file_addr, 703 uint32_t resolve_scope, 704 Address& so_addr, 705 SymbolContext& sc); 706 707 void 708 SymbolIndicesToSymbolContextList (Symtab *symtab, 709 std::vector<uint32_t> &symbol_indexes, 710 SymbolContextList &sc_list); 711 712 bool 713 SetArchitecture (const ArchSpec &new_arch); 714 715private: 716 717 uint32_t 718 FindTypes_Impl (const SymbolContext& sc, 719 const ConstString &name, 720 bool append, 721 uint32_t max_matches, 722 TypeList& types); 723 724 725 DISALLOW_COPY_AND_ASSIGN (Module); 726}; 727 728} // namespace lldb_private 729 730#endif // liblldb_Module_h_ 731