contrib/llvm/tools/lldb/source/API/SBModule.cpp

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