contrib/llvm-project/lldb/source/API/SBModule.cpp

   1 //===-- SBModule.cpp --------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/API/SBModule.h"
  10 #include "SBReproducerPrivate.h"
  11 #include "lldb/API/SBAddress.h"
  12 #include "lldb/API/SBFileSpec.h"
  13 #include "lldb/API/SBModuleSpec.h"
  14 #include "lldb/API/SBProcess.h"
  15 #include "lldb/API/SBStream.h"
  16 #include "lldb/API/SBSymbolContextList.h"
  17 #include "lldb/Core/Module.h"
  18 #include "lldb/Core/Section.h"
  19 #include "lldb/Core/ValueObjectList.h"
  20 #include "lldb/Core/ValueObjectVariable.h"
  21 #include "lldb/Symbol/ObjectFile.h"
  22 #include "lldb/Symbol/SymbolFile.h"
  23 #include "lldb/Symbol/SymbolVendor.h"
  24 #include "lldb/Symbol/Symtab.h"
  25 #include "lldb/Symbol/TypeSystem.h"
  26 #include "lldb/Symbol/VariableList.h"
  27 #include "lldb/Target/Target.h"
  28 #include "lldb/Utility/StreamString.h"
  29
  30 using namespace lldb;
  31 using namespace lldb_private;
  32
  33 SBModule::SBModule() : m_opaque_sp() {
  34   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBModule);
  35 }
  36
  37 SBModule::SBModule(const lldb::ModuleSP &module_sp) : m_opaque_sp(module_sp) {}
  38
  39 SBModule::SBModule(const SBModuleSpec &module_spec) : m_opaque_sp() {
  40   LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &), module_spec);
  41
  42   ModuleSP module_sp;
  43   Status error = ModuleList::GetSharedModule(
  44       *module_spec.m_opaque_up, module_sp, nullptr, nullptr, nullptr);
  45   if (module_sp)
  46     SetSP(module_sp);
  47 }
  48
  49 SBModule::SBModule(const SBModule &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
  50   LLDB_RECORD_CONSTRUCTOR(SBModule, (const lldb::SBModule &), rhs);
  51 }
  52
  53 SBModule::SBModule(lldb::SBProcess &process, lldb::addr_t header_addr)
  54     : m_opaque_sp() {
  55   LLDB_RECORD_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t), process,
  56                           header_addr);
  57
  58   ProcessSP process_sp(process.GetSP());
  59   if (process_sp) {
  60     m_opaque_sp = process_sp->ReadModuleFromMemory(FileSpec(), header_addr);
  61     if (m_opaque_sp) {
  62       Target &target = process_sp->GetTarget();
  63       bool changed = false;
  64       m_opaque_sp->SetLoadAddress(target, 0, true, changed);
  65       target.GetImages().Append(m_opaque_sp);
  66     }
  67   }
  68 }
  69
  70 const SBModule &SBModule::operator=(const SBModule &rhs) {
  71   LLDB_RECORD_METHOD(const lldb::SBModule &,
  72                      SBModule, operator=,(const lldb::SBModule &), rhs);
  73
  74   if (this != &rhs)
  75     m_opaque_sp = rhs.m_opaque_sp;
  76   return LLDB_RECORD_RESULT(*this);
  77 }
  78
  79 SBModule::~SBModule() {}
  80
  81 bool SBModule::IsValid() const {
  82   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid);
  83   return this->operator bool();
  84 }
  85 SBModule::operator bool() const {
  86   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, operator bool);
  87
  88   return m_opaque_sp.get() != nullptr;
  89 }
  90
  91 void SBModule::Clear() {
  92   LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear);
  93
  94   m_opaque_sp.reset();
  95 }
  96
  97 SBFileSpec SBModule::GetFileSpec() const {
  98   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule, GetFileSpec);
  99
 100   SBFileSpec file_spec;
 101   ModuleSP module_sp(GetSP());
 102   if (module_sp)
 103     file_spec.SetFileSpec(module_sp->GetFileSpec());
 104
 105   return LLDB_RECORD_RESULT(file_spec);
 106 }
 107
 108 lldb::SBFileSpec SBModule::GetPlatformFileSpec() const {
 109   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
 110                                    GetPlatformFileSpec);
 111
 112
 113   SBFileSpec file_spec;
 114   ModuleSP module_sp(GetSP());
 115   if (module_sp)
 116     file_spec.SetFileSpec(module_sp->GetPlatformFileSpec());
 117
 118   return LLDB_RECORD_RESULT(file_spec);
 119 }
 120
 121 bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
 122   LLDB_RECORD_METHOD(bool, SBModule, SetPlatformFileSpec,
 123                      (const lldb::SBFileSpec &), platform_file);
 124
 125   bool result = false;
 126
 127   ModuleSP module_sp(GetSP());
 128   if (module_sp) {
 129     module_sp->SetPlatformFileSpec(*platform_file);
 130     result = true;
 131   }
 132
 133   return result;
 134 }
 135
 136 lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
 137   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBModule,
 138                              GetRemoteInstallFileSpec);
 139
 140   SBFileSpec sb_file_spec;
 141   ModuleSP module_sp(GetSP());
 142   if (module_sp)
 143     sb_file_spec.SetFileSpec(module_sp->GetRemoteInstallFileSpec());
 144   return LLDB_RECORD_RESULT(sb_file_spec);
 145 }
 146
 147 bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
 148   LLDB_RECORD_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
 149                      (lldb::SBFileSpec &), file);
 150
 151   ModuleSP module_sp(GetSP());
 152   if (module_sp) {
 153     module_sp->SetRemoteInstallFileSpec(file.ref());
 154     return true;
 155   }
 156   return false;
 157 }
 158
 159 const uint8_t *SBModule::GetUUIDBytes() const {
 160   LLDB_RECORD_METHOD_CONST_NO_ARGS(const uint8_t *, SBModule, GetUUIDBytes);
 161
 162   const uint8_t *uuid_bytes = nullptr;
 163   ModuleSP module_sp(GetSP());
 164   if (module_sp)
 165     uuid_bytes = module_sp->GetUUID().GetBytes().data();
 166
 167   return uuid_bytes;
 168 }
 169
 170 const char *SBModule::GetUUIDString() const {
 171   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBModule, GetUUIDString);
 172
 173   const char *uuid_cstr = nullptr;
 174   ModuleSP module_sp(GetSP());
 175   if (module_sp) {
 176     // We are going to return a "const char *" value through the public API, so
 177     // we need to constify it so it gets added permanently the string pool and
 178     // then we don't need to worry about the lifetime of the string as it will
 179     // never go away once it has been put into the ConstString string pool
 180     uuid_cstr = ConstString(module_sp->GetUUID().GetAsString()).GetCString();
 181   }
 182
 183   if (uuid_cstr && uuid_cstr[0]) {
 184     return uuid_cstr;
 185   }
 186
 187   return nullptr;
 188 }
 189
 190 bool SBModule::operator==(const SBModule &rhs) const {
 191   LLDB_RECORD_METHOD_CONST(bool, SBModule, operator==,(const lldb::SBModule &),
 192                            rhs);
 193
 194   if (m_opaque_sp)
 195     return m_opaque_sp.get() == rhs.m_opaque_sp.get();
 196   return false;
 197 }
 198
 199 bool SBModule::operator!=(const SBModule &rhs) const {
 200   LLDB_RECORD_METHOD_CONST(bool, SBModule, operator!=,(const lldb::SBModule &),
 201                            rhs);
 202
 203   if (m_opaque_sp)
 204     return m_opaque_sp.get() != rhs.m_opaque_sp.get();
 205   return false;
 206 }
 207
 208 ModuleSP SBModule::GetSP() const { return m_opaque_sp; }
 209
 210 void SBModule::SetSP(const ModuleSP &module_sp) { m_opaque_sp = module_sp; }
 211
 212 SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
 213   LLDB_RECORD_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
 214                      (lldb::addr_t), vm_addr);
 215
 216   lldb::SBAddress sb_addr;
 217   ModuleSP module_sp(GetSP());
 218   if (module_sp) {
 219     Address addr;
 220     if (module_sp->ResolveFileAddress(vm_addr, addr))
 221       sb_addr.ref() = addr;
 222   }
 223   return LLDB_RECORD_RESULT(sb_addr);
 224 }
 225
 226 SBSymbolContext
 227 SBModule::ResolveSymbolContextForAddress(const SBAddress &addr,
 228                                          uint32_t resolve_scope) {
 229   LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBModule,
 230                      ResolveSymbolContextForAddress,
 231                      (const lldb::SBAddress &, uint32_t), addr, resolve_scope);
 232
 233   SBSymbolContext sb_sc;
 234   ModuleSP module_sp(GetSP());
 235   SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
 236   if (module_sp && addr.IsValid())
 237     module_sp->ResolveSymbolContextForAddress(addr.ref(), scope, *sb_sc);
 238   return LLDB_RECORD_RESULT(sb_sc);
 239 }
 240
 241 bool SBModule::GetDescription(SBStream &description) {
 242   LLDB_RECORD_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &),
 243                      description);
 244
 245   Stream &strm = description.ref();
 246
 247   ModuleSP module_sp(GetSP());
 248   if (module_sp) {
 249     module_sp->GetDescription(&strm);
 250   } else
 251     strm.PutCString("No value");
 252
 253   return true;
 254 }
 255
 256 uint32_t SBModule::GetNumCompileUnits() {
 257   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits);
 258
 259   ModuleSP module_sp(GetSP());
 260   if (module_sp) {
 261     return module_sp->GetNumCompileUnits();
 262   }
 263   return 0;
 264 }
 265
 266 SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
 267   LLDB_RECORD_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
 268                      (uint32_t), index);
 269
 270   SBCompileUnit sb_cu;
 271   ModuleSP module_sp(GetSP());
 272   if (module_sp) {
 273     CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(index);
 274     sb_cu.reset(cu_sp.get());
 275   }
 276   return LLDB_RECORD_RESULT(sb_cu);
 277 }
 278
 279 SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
 280   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
 281                      (const lldb::SBFileSpec &), sb_file_spec);
 282
 283   SBSymbolContextList sb_sc_list;
 284   const ModuleSP module_sp(GetSP());
 285   if (sb_file_spec.IsValid() && module_sp) {
 286     const bool append = true;
 287     module_sp->FindCompileUnits(*sb_file_spec, append, *sb_sc_list);
 288   }
 289   return LLDB_RECORD_RESULT(sb_sc_list);
 290 }
 291
 292 static Symtab *GetUnifiedSymbolTable(const lldb::ModuleSP &module_sp) {
 293   if (module_sp) {
 294     SymbolVendor *symbols = module_sp->GetSymbolVendor();
 295     if (symbols)
 296       return symbols->GetSymtab();
 297   }
 298   return nullptr;
 299 }
 300
 301 size_t SBModule::GetNumSymbols() {
 302   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSymbols);
 303
 304   ModuleSP module_sp(GetSP());
 305   if (module_sp) {
 306     Symtab *symtab = GetUnifiedSymbolTable(module_sp);
 307     if (symtab)
 308       return symtab->GetNumSymbols();
 309   }
 310   return 0;
 311 }
 312
 313 SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
 314   LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t), idx);
 315
 316   SBSymbol sb_symbol;
 317   ModuleSP module_sp(GetSP());
 318   Symtab *symtab = GetUnifiedSymbolTable(module_sp);
 319   if (symtab)
 320     sb_symbol.SetSymbol(symtab->SymbolAtIndex(idx));
 321   return LLDB_RECORD_RESULT(sb_symbol);
 322 }
 323
 324 lldb::SBSymbol SBModule::FindSymbol(const char *name,
 325                                     lldb::SymbolType symbol_type) {
 326   LLDB_RECORD_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
 327                      (const char *, lldb::SymbolType), name, symbol_type);
 328
 329   SBSymbol sb_symbol;
 330   if (name && name[0]) {
 331     ModuleSP module_sp(GetSP());
 332     Symtab *symtab = GetUnifiedSymbolTable(module_sp);
 333     if (symtab)
 334       sb_symbol.SetSymbol(symtab->FindFirstSymbolWithNameAndType(
 335           ConstString(name), symbol_type, Symtab::eDebugAny,
 336           Symtab::eVisibilityAny));
 337   }
 338   return LLDB_RECORD_RESULT(sb_symbol);
 339 }
 340
 341 lldb::SBSymbolContextList SBModule::FindSymbols(const char *name,
 342                                                 lldb::SymbolType symbol_type) {
 343   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
 344                      (const char *, lldb::SymbolType), name, symbol_type);
 345
 346   SBSymbolContextList sb_sc_list;
 347   if (name && name[0]) {
 348     ModuleSP module_sp(GetSP());
 349     Symtab *symtab = GetUnifiedSymbolTable(module_sp);
 350     if (symtab) {
 351       std::vector<uint32_t> matching_symbol_indexes;
 352       const size_t num_matches = symtab->FindAllSymbolsWithNameAndType(
 353           ConstString(name), symbol_type, matching_symbol_indexes);
 354       if (num_matches) {
 355         SymbolContext sc;
 356         sc.module_sp = module_sp;
 357         SymbolContextList &sc_list = *sb_sc_list;
 358         for (size_t i = 0; i < num_matches; ++i) {
 359           sc.symbol = symtab->SymbolAtIndex(matching_symbol_indexes[i]);
 360           if (sc.symbol)
 361             sc_list.Append(sc);
 362         }
 363       }
 364     }
 365   }
 366   return LLDB_RECORD_RESULT(sb_sc_list);
 367 }
 368
 369 size_t SBModule::GetNumSections() {
 370   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBModule, GetNumSections);
 371
 372   ModuleSP module_sp(GetSP());
 373   if (module_sp) {
 374     // Give the symbol vendor a chance to add to the unified section list.
 375     module_sp->GetSymbolVendor();
 376     SectionList *section_list = module_sp->GetSectionList();
 377     if (section_list)
 378       return section_list->GetSize();
 379   }
 380   return 0;
 381 }
 382
 383 SBSection SBModule::GetSectionAtIndex(size_t idx) {
 384   LLDB_RECORD_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex, (size_t),
 385                      idx);
 386
 387   SBSection sb_section;
 388   ModuleSP module_sp(GetSP());
 389   if (module_sp) {
 390     // Give the symbol vendor a chance to add to the unified section list.
 391     module_sp->GetSymbolVendor();
 392     SectionList *section_list = module_sp->GetSectionList();
 393
 394     if (section_list)
 395       sb_section.SetSP(section_list->GetSectionAtIndex(idx));
 396   }
 397   return LLDB_RECORD_RESULT(sb_section);
 398 }
 399
 400 lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
 401                                                   uint32_t name_type_mask) {
 402   LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
 403                      (const char *, uint32_t), name, name_type_mask);
 404
 405   lldb::SBSymbolContextList sb_sc_list;
 406   ModuleSP module_sp(GetSP());
 407   if (name && module_sp) {
 408     const bool append = true;
 409     const bool symbols_ok = true;
 410     const bool inlines_ok = true;
 411     FunctionNameType type = static_cast<FunctionNameType>(name_type_mask);
 412     module_sp->FindFunctions(ConstString(name), nullptr, type, symbols_ok,
 413                              inlines_ok, append, *sb_sc_list);
 414   }
 415   return LLDB_RECORD_RESULT(sb_sc_list);
 416 }
 417
 418 SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
 419                                           uint32_t max_matches) {
 420   LLDB_RECORD_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
 421                      (lldb::SBTarget &, const char *, uint32_t), target, name,
 422                      max_matches);
 423
 424   SBValueList sb_value_list;
 425   ModuleSP module_sp(GetSP());
 426   if (name && module_sp) {
 427     VariableList variable_list;
 428     const uint32_t match_count = module_sp->FindGlobalVariables(
 429         ConstString(name), nullptr, max_matches, variable_list);
 430
 431     if (match_count > 0) {
 432       for (uint32_t i = 0; i < match_count; ++i) {
 433         lldb::ValueObjectSP valobj_sp;
 434         TargetSP target_sp(target.GetSP());
 435         valobj_sp = ValueObjectVariable::Create(
 436             target_sp.get(), variable_list.GetVariableAtIndex(i));
 437         if (valobj_sp)
 438           sb_value_list.Append(SBValue(valobj_sp));
 439       }
 440     }
 441   }
 442
 443   return LLDB_RECORD_RESULT(sb_value_list);
 444 }
 445
 446 lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
 447                                                 const char *name) {
 448   LLDB_RECORD_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
 449                      (lldb::SBTarget &, const char *), target, name);
 450
 451   SBValueList sb_value_list(FindGlobalVariables(target, name, 1));
 452   if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
 453     return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0));
 454   return LLDB_RECORD_RESULT(SBValue());
 455 }
 456
 457 lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
 458   LLDB_RECORD_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *),
 459                      name_cstr);
 460
 461   SBType sb_type;
 462   ModuleSP module_sp(GetSP());
 463   if (name_cstr && module_sp) {
 464     SymbolContext sc;
 465     const bool exact_match = false;
 466     ConstString name(name_cstr);
 467
 468     sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match));
 469
 470     if (!sb_type.IsValid()) {
 471       TypeSystem *type_system =
 472           module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
 473       if (type_system)
 474         sb_type = SBType(type_system->GetBuiltinTypeByName(name));
 475     }
 476   }
 477   return LLDB_RECORD_RESULT(sb_type);
 478 }
 479
 480 lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
 481   LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType),
 482                      type);
 483
 484   ModuleSP module_sp(GetSP());
 485   if (module_sp) {
 486     TypeSystem *type_system =
 487         module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
 488     if (type_system)
 489       return LLDB_RECORD_RESULT(SBType(type_system->GetBasicTypeFromAST(type)));
 490   }
 491   return LLDB_RECORD_RESULT(SBType());
 492 }
 493
 494 lldb::SBTypeList SBModule::FindTypes(const char *type) {
 495   LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *),
 496                      type);
 497
 498   SBTypeList retval;
 499
 500   ModuleSP module_sp(GetSP());
 501   if (type && module_sp) {
 502     TypeList type_list;
 503     const bool exact_match = false;
 504     ConstString name(type);
 505     llvm::DenseSet<SymbolFile *> searched_symbol_files;
 506     const uint32_t num_matches = module_sp->FindTypes(
 507         name, exact_match, UINT32_MAX, searched_symbol_files, type_list);
 508
 509     if (num_matches > 0) {
 510       for (size_t idx = 0; idx < num_matches; idx++) {
 511         TypeSP type_sp(type_list.GetTypeAtIndex(idx));
 512         if (type_sp)
 513           retval.Append(SBType(type_sp));
 514       }
 515     } else {
 516       TypeSystem *type_system =
 517           module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
 518       if (type_system) {
 519         CompilerType compiler_type = type_system->GetBuiltinTypeByName(name);
 520         if (compiler_type)
 521           retval.Append(SBType(compiler_type));
 522       }
 523     }
 524   }
 525
 526   return LLDB_RECORD_RESULT(retval);
 527 }
 528
 529 lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
 530   LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetTypeByID, (lldb::user_id_t),
 531                      uid);
 532
 533   ModuleSP module_sp(GetSP());
 534   if (module_sp) {
 535     SymbolVendor *vendor = module_sp->GetSymbolVendor();
 536     if (vendor) {
 537       Type *type_ptr = vendor->ResolveTypeUID(uid);
 538       if (type_ptr)
 539         return LLDB_RECORD_RESULT(SBType(type_ptr->shared_from_this()));
 540     }
 541   }
 542   return LLDB_RECORD_RESULT(SBType());
 543 }
 544
 545 lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
 546   LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t),
 547                      type_mask);
 548
 549   SBTypeList sb_type_list;
 550
 551   ModuleSP module_sp(GetSP());
 552   if (!module_sp)
 553     return LLDB_RECORD_RESULT(sb_type_list);
 554   SymbolVendor *vendor = module_sp->GetSymbolVendor();
 555   if (!vendor)
 556     return LLDB_RECORD_RESULT(sb_type_list);
 557
 558   TypeClass type_class = static_cast<TypeClass>(type_mask);
 559   TypeList type_list;
 560   vendor->GetTypes(nullptr, type_class, type_list);
 561   sb_type_list.m_opaque_up->Append(type_list);
 562   return LLDB_RECORD_RESULT(sb_type_list);
 563 }
 564
 565 SBSection SBModule::FindSection(const char *sect_name) {
 566   LLDB_RECORD_METHOD(lldb::SBSection, SBModule, FindSection, (const char *),
 567                      sect_name);
 568
 569   SBSection sb_section;
 570
 571   ModuleSP module_sp(GetSP());
 572   if (sect_name && module_sp) {
 573     // Give the symbol vendor a chance to add to the unified section list.
 574     module_sp->GetSymbolVendor();
 575     SectionList *section_list = module_sp->GetSectionList();
 576     if (section_list) {
 577       ConstString const_sect_name(sect_name);
 578       SectionSP section_sp(section_list->FindSectionByName(const_sect_name));
 579       if (section_sp) {
 580         sb_section.SetSP(section_sp);
 581       }
 582     }
 583   }
 584   return LLDB_RECORD_RESULT(sb_section);
 585 }
 586
 587 lldb::ByteOrder SBModule::GetByteOrder() {
 588   LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBModule, GetByteOrder);
 589
 590   ModuleSP module_sp(GetSP());
 591   if (module_sp)
 592     return module_sp->GetArchitecture().GetByteOrder();
 593   return eByteOrderInvalid;
 594 }
 595
 596 const char *SBModule::GetTriple() {
 597   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBModule, GetTriple);
 598
 599   ModuleSP module_sp(GetSP());
 600   if (module_sp) {
 601     std::string triple(module_sp->GetArchitecture().GetTriple().str());
 602     // Unique the string so we don't run into ownership issues since the const
 603     // strings put the string into the string pool once and the strings never
 604     // comes out
 605     ConstString const_triple(triple.c_str());
 606     return const_triple.GetCString();
 607   }
 608   return nullptr;
 609 }
 610
 611 uint32_t SBModule::GetAddressByteSize() {
 612   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetAddressByteSize);
 613
 614   ModuleSP module_sp(GetSP());
 615   if (module_sp)
 616     return module_sp->GetArchitecture().GetAddressByteSize();
 617   return sizeof(void *);
 618 }
 619
 620 uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {
 621   LLDB_RECORD_METHOD(uint32_t, SBModule, GetVersion, (uint32_t *, uint32_t),
 622                      versions, num_versions);
 623
 624   llvm::VersionTuple version;
 625   if (ModuleSP module_sp = GetSP())
 626     version = module_sp->GetVersion();
 627   uint32_t result = 0;
 628   if (!version.empty())
 629     ++result;
 630   if (version.getMinor())
 631     ++result;
 632   if(version.getSubminor())
 633     ++result;
 634
 635   if (!versions)
 636     return result;
 637
 638   if (num_versions > 0)
 639     versions[0] = version.empty() ? UINT32_MAX : version.getMajor();
 640   if (num_versions > 1)
 641     versions[1] = version.getMinor().getValueOr(UINT32_MAX);
 642   if (num_versions > 2)
 643     versions[2] = version.getSubminor().getValueOr(UINT32_MAX);
 644   for (uint32_t i = 3; i < num_versions; ++i)
 645     versions[i] = UINT32_MAX;
 646   return result;
 647 }
 648
 649 lldb::SBFileSpec SBModule::GetSymbolFileSpec() const {
 650   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBModule,
 651                                    GetSymbolFileSpec);
 652
 653   lldb::SBFileSpec sb_file_spec;
 654   ModuleSP module_sp(GetSP());
 655   if (module_sp) {
 656     SymbolVendor *symbol_vendor_ptr = module_sp->GetSymbolVendor();
 657     if (symbol_vendor_ptr)
 658       sb_file_spec.SetFileSpec(symbol_vendor_ptr->GetMainFileSpec());
 659   }
 660   return LLDB_RECORD_RESULT(sb_file_spec);
 661 }
 662
 663 lldb::SBAddress SBModule::GetObjectFileHeaderAddress() const {
 664   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
 665                                    GetObjectFileHeaderAddress);
 666
 667   lldb::SBAddress sb_addr;
 668   ModuleSP module_sp(GetSP());
 669   if (module_sp) {
 670     ObjectFile *objfile_ptr = module_sp->GetObjectFile();
 671     if (objfile_ptr)
 672       sb_addr.ref() = objfile_ptr->GetBaseAddress();
 673   }
 674   return LLDB_RECORD_RESULT(sb_addr);
 675 }
 676
 677 lldb::SBAddress SBModule::GetObjectFileEntryPointAddress() const {
 678   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBModule,
 679                                    GetObjectFileEntryPointAddress);
 680
 681   lldb::SBAddress sb_addr;
 682   ModuleSP module_sp(GetSP());
 683   if (module_sp) {
 684     ObjectFile *objfile_ptr = module_sp->GetObjectFile();
 685     if (objfile_ptr)
 686       sb_addr.ref() = objfile_ptr->GetEntryPointAddress();
 687   }
 688   return LLDB_RECORD_RESULT(sb_addr);
 689 }
 690
 691 namespace lldb_private {
 692 namespace repro {
 693
 694 template <>
 695 void RegisterMethods<SBModule>(Registry &R) {
 696   LLDB_REGISTER_CONSTRUCTOR(SBModule, ());
 697   LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &));
 698   LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModule &));
 699   LLDB_REGISTER_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t));
 700   LLDB_REGISTER_METHOD(const lldb::SBModule &,
 701                        SBModule, operator=,(const lldb::SBModule &));
 702   LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsValid, ());
 703   LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator bool, ());
 704   LLDB_REGISTER_METHOD(void, SBModule, Clear, ());
 705   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetFileSpec, ());
 706   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetPlatformFileSpec,
 707                              ());
 708   LLDB_REGISTER_METHOD(bool, SBModule, SetPlatformFileSpec,
 709                        (const lldb::SBFileSpec &));
 710   LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec,
 711                        ());
 712   LLDB_REGISTER_METHOD(bool, SBModule, SetRemoteInstallFileSpec,
 713                        (lldb::SBFileSpec &));
 714   LLDB_REGISTER_METHOD_CONST(const char *, SBModule, GetUUIDString, ());
 715   LLDB_REGISTER_METHOD_CONST(bool,
 716                              SBModule, operator==,(const lldb::SBModule &));
 717   LLDB_REGISTER_METHOD_CONST(bool,
 718                              SBModule, operator!=,(const lldb::SBModule &));
 719   LLDB_REGISTER_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
 720                        (lldb::addr_t));
 721   LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBModule,
 722                        ResolveSymbolContextForAddress,
 723                        (const lldb::SBAddress &, uint32_t));
 724   LLDB_REGISTER_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &));
 725   LLDB_REGISTER_METHOD(uint32_t, SBModule, GetNumCompileUnits, ());
 726   LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
 727                        (uint32_t));
 728   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
 729                        (const lldb::SBFileSpec &));
 730   LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSymbols, ());
 731   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t));
 732   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, FindSymbol,
 733                        (const char *, lldb::SymbolType));
 734   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindSymbols,
 735                        (const char *, lldb::SymbolType));
 736   LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSections, ());
 737   LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, GetSectionAtIndex,
 738                        (size_t));
 739   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindFunctions,
 740                        (const char *, uint32_t));
 741   LLDB_REGISTER_METHOD(lldb::SBValueList, SBModule, FindGlobalVariables,
 742                        (lldb::SBTarget &, const char *, uint32_t));
 743   LLDB_REGISTER_METHOD(lldb::SBValue, SBModule, FindFirstGlobalVariable,
 744                        (lldb::SBTarget &, const char *));
 745   LLDB_REGISTER_METHOD(lldb::SBType, SBModule, FindFirstType, (const char *));
 746   LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetBasicType,
 747                        (lldb::BasicType));
 748   LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *));
 749   LLDB_REGISTER_METHOD(lldb::SBType, SBModule, GetTypeByID,
 750                        (lldb::user_id_t));
 751   LLDB_REGISTER_METHOD(lldb::SBTypeList, SBModule, GetTypes, (uint32_t));
 752   LLDB_REGISTER_METHOD(lldb::SBSection, SBModule, FindSection,
 753                        (const char *));
 754   LLDB_REGISTER_METHOD(lldb::ByteOrder, SBModule, GetByteOrder, ());
 755   LLDB_REGISTER_METHOD(const char *, SBModule, GetTriple, ());
 756   LLDB_REGISTER_METHOD(uint32_t, SBModule, GetAddressByteSize, ());
 757   LLDB_REGISTER_METHOD(uint32_t, SBModule, GetVersion,
 758                        (uint32_t *, uint32_t));
 759   LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetSymbolFileSpec,
 760                              ());
 761   LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
 762                              GetObjectFileHeaderAddress, ());
 763   LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
 764                              GetObjectFileEntryPointAddress, ());
 765 }
 766
 767 }
 768 }