contrib/llvm/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

   1 //===-- SymbolFileDWARFDebugMap.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 "SymbolFileDWARFDebugMap.h"
  11
  12 #include "DWARFDebugAranges.h"
  13
  14 #include "lldb/Core/RangeMap.h"
  15 #include "lldb/Core/Module.h"
  16 #include "lldb/Core/ModuleList.h"
  17 #include "lldb/Core/PluginManager.h"
  18 #include "lldb/Core/RegularExpression.h"
  19 #include "lldb/Core/Section.h"
  20
  21 //#define DEBUG_OSO_DMAP // DO NOT CHECKIN WITH THIS NOT COMMENTED OUT
  22 #if defined(DEBUG_OSO_DMAP)
  23 #include "lldb/Core/StreamFile.h"
  24 #endif
  25 #include "lldb/Core/Timer.h"
  26
  27 #include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
  28 #include "lldb/Symbol/CompileUnit.h"
  29 #include "lldb/Symbol/LineTable.h"
  30 #include "lldb/Symbol/ObjectFile.h"
  31 #include "lldb/Symbol/SymbolVendor.h"
  32 #include "lldb/Symbol/VariableList.h"
  33
  34 #include "LogChannelDWARF.h"
  35 #include "SymbolFileDWARF.h"
  36
  37 using namespace lldb;
  38 using namespace lldb_private;
  39
  40 // Subclass lldb_private::Module so we can intercept the "Module::GetObjectFile()"
  41 // (so we can fixup the object file sections) and also for "Module::GetSymbolVendor()"
  42 // (so we can fixup the symbol file id.
  43
  44
  45
  46
  47 const SymbolFileDWARFDebugMap::FileRangeMap &
  48 SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap(SymbolFileDWARFDebugMap *exe_symfile)
  49 {
  50     if (file_range_map_valid)
  51         return file_range_map;
  52
  53     file_range_map_valid = true;
  54
  55     Module *oso_module = exe_symfile->GetModuleByCompUnitInfo (this);
  56     if (!oso_module)
  57         return file_range_map;
  58
  59     ObjectFile *oso_objfile = oso_module->GetObjectFile();
  60     if (!oso_objfile)
  61         return file_range_map;
  62
  63     Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP));
  64     if (log)
  65     {
  66         ConstString object_name (oso_module->GetObjectName());
  67         log->Printf("%p: SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap ('%s')",
  68                     static_cast<void*>(this),
  69                     oso_module->GetSpecificationDescription().c_str());
  70     }
  71
  72     std::vector<SymbolFileDWARFDebugMap::CompileUnitInfo *> cu_infos;
  73     if (exe_symfile->GetCompUnitInfosForModule(oso_module, cu_infos))
  74     {
  75         for (auto comp_unit_info : cu_infos)
  76         {
  77             Symtab *exe_symtab = exe_symfile->GetObjectFile()->GetSymtab();
  78             ModuleSP oso_module_sp (oso_objfile->GetModule());
  79             Symtab *oso_symtab = oso_objfile->GetSymtab();
  80
  81             ///const uint32_t fun_resolve_flags = SymbolContext::Module | eSymbolContextCompUnit | eSymbolContextFunction;
  82             //SectionList *oso_sections = oso_objfile->Sections();
  83             // Now we need to make sections that map from zero based object
  84             // file addresses to where things ended up in the main executable.
  85
  86             assert (comp_unit_info->first_symbol_index != UINT32_MAX);
  87             // End index is one past the last valid symbol index
  88             const uint32_t oso_end_idx = comp_unit_info->last_symbol_index + 1;
  89             for (uint32_t idx = comp_unit_info->first_symbol_index + 2; // Skip the N_SO and N_OSO
  90                  idx < oso_end_idx;
  91                  ++idx)
  92             {
  93                 Symbol *exe_symbol = exe_symtab->SymbolAtIndex(idx);
  94                 if (exe_symbol)
  95                 {
  96                     if (exe_symbol->IsDebug() == false)
  97                         continue;
  98
  99                     switch (exe_symbol->GetType())
 100                     {
 101                     default:
 102                         break;
 103
 104                     case eSymbolTypeCode:
 105                         {
 106                             // For each N_FUN, or function that we run into in the debug map
 107                             // we make a new section that we add to the sections found in the
 108                             // .o file. This new section has the file address set to what the
 109                             // addresses are in the .o file, and the load address is adjusted
 110                             // to match where it ended up in the final executable! We do this
 111                             // before we parse any dwarf info so that when it goes get parsed
 112                             // all section/offset addresses that get registered will resolve
 113                             // correctly to the new addresses in the main executable.
 114
 115                             // First we find the original symbol in the .o file's symbol table
 116                             Symbol *oso_fun_symbol = oso_symtab->FindFirstSymbolWithNameAndType (exe_symbol->GetMangled().GetName(Mangled::ePreferMangled),
 117                                                                                                  eSymbolTypeCode,
 118                                                                                                  Symtab::eDebugNo,
 119                                                                                                  Symtab::eVisibilityAny);
 120                             if (oso_fun_symbol)
 121                             {
 122                                 // Add the inverse OSO file address to debug map entry mapping
 123                                 exe_symfile->AddOSOFileRange (this,
 124                                                               exe_symbol->GetAddress().GetFileAddress(),
 125                                                               oso_fun_symbol->GetAddress().GetFileAddress(),
 126                                                               std::min<addr_t>(exe_symbol->GetByteSize(), oso_fun_symbol->GetByteSize()));
 127
 128                             }
 129                         }
 130                         break;
 131
 132                     case eSymbolTypeData:
 133                         {
 134                             // For each N_GSYM we remap the address for the global by making
 135                             // a new section that we add to the sections found in the .o file.
 136                             // This new section has the file address set to what the
 137                             // addresses are in the .o file, and the load address is adjusted
 138                             // to match where it ended up in the final executable! We do this
 139                             // before we parse any dwarf info so that when it goes get parsed
 140                             // all section/offset addresses that get registered will resolve
 141                             // correctly to the new addresses in the main executable. We
 142                             // initially set the section size to be 1 byte, but will need to
 143                             // fix up these addresses further after all globals have been
 144                             // parsed to span the gaps, or we can find the global variable
 145                             // sizes from the DWARF info as we are parsing.
 146
 147                             // Next we find the non-stab entry that corresponds to the N_GSYM in the .o file
 148                             Symbol *oso_gsym_symbol = oso_symtab->FindFirstSymbolWithNameAndType (exe_symbol->GetMangled().GetName(Mangled::ePreferMangled),
 149                                                                                                   eSymbolTypeData,
 150                                                                                                   Symtab::eDebugNo,
 151                                                                                                   Symtab::eVisibilityAny);
 152                             if (exe_symbol && oso_gsym_symbol &&
 153                                 exe_symbol->ValueIsAddress() &&
 154                                 oso_gsym_symbol->ValueIsAddress())
 155                             {
 156                                 // Add the inverse OSO file address to debug map entry mapping
 157                                 exe_symfile->AddOSOFileRange (this,
 158                                                               exe_symbol->GetAddress().GetFileAddress(),
 159                                                               oso_gsym_symbol->GetAddress().GetFileAddress(),
 160                                                               std::min<addr_t>(exe_symbol->GetByteSize(), oso_gsym_symbol->GetByteSize()));
 161                             }
 162                         }
 163                         break;
 164                     }
 165                 }
 166             }
 167
 168             exe_symfile->FinalizeOSOFileRanges (this);
 169             // We don't need the symbols anymore for the .o files
 170             oso_objfile->ClearSymtab();
 171         }
 172     }
 173     return file_range_map;
 174 }
 175
 176
 177 class DebugMapModule : public Module
 178 {
 179 public:
 180     DebugMapModule (const ModuleSP &exe_module_sp,
 181                     uint32_t cu_idx,
 182                     const FileSpec& file_spec,
 183                     const ArchSpec& arch,
 184                     const ConstString *object_name,
 185                     off_t object_offset,
 186                     const TimeValue *object_mod_time_ptr) :
 187         Module (file_spec, arch, object_name, object_offset, object_mod_time_ptr),
 188         m_exe_module_wp (exe_module_sp),
 189         m_cu_idx (cu_idx)
 190     {
 191     }
 192
 193     virtual
 194     ~DebugMapModule ()
 195     {
 196     }
 197
 198
 199     virtual SymbolVendor*
 200     GetSymbolVendor(bool can_create = true, lldb_private::Stream *feedback_strm = NULL)
 201     {
 202         // Scope for locker
 203         if (m_symfile_ap.get() || can_create == false)
 204             return m_symfile_ap.get();
 205
 206         ModuleSP exe_module_sp (m_exe_module_wp.lock());
 207         if (exe_module_sp)
 208         {
 209             // Now get the object file outside of a locking scope
 210             ObjectFile *oso_objfile = GetObjectFile ();
 211             if (oso_objfile)
 212             {
 213                 Mutex::Locker locker (m_mutex);
 214                 SymbolVendor* symbol_vendor = Module::GetSymbolVendor(can_create, feedback_strm);
 215                 if (symbol_vendor)
 216                 {
 217                     // Set a pointer to this class to set our OSO DWARF file know
 218                     // that the DWARF is being used along with a debug map and that
 219                     // it will have the remapped sections that we do below.
 220                     SymbolFileDWARF *oso_symfile = SymbolFileDWARFDebugMap::GetSymbolFileAsSymbolFileDWARF(symbol_vendor->GetSymbolFile());
 221
 222                     if (!oso_symfile)
 223                         return NULL;
 224
 225                     ObjectFile *exe_objfile = exe_module_sp->GetObjectFile();
 226                     SymbolVendor *exe_sym_vendor = exe_module_sp->GetSymbolVendor();
 227
 228                     if (exe_objfile && exe_sym_vendor)
 229                     {
 230                         if (oso_symfile->GetNumCompileUnits() == 1)
 231                         {
 232                             oso_symfile->SetDebugMapModule(exe_module_sp);
 233                             // Set the ID of the symbol file DWARF to the index of the OSO
 234                             // shifted left by 32 bits to provide a unique prefix for any
 235                             // UserID's that get created in the symbol file.
 236                             oso_symfile->SetID (((uint64_t)m_cu_idx + 1ull) << 32ull);
 237                         }
 238                         else
 239                         {
 240                             oso_symfile->SetID (UINT64_MAX);
 241                         }
 242                     }
 243                     return symbol_vendor;
 244                 }
 245             }
 246         }
 247         return NULL;
 248     }
 249
 250 protected:
 251     ModuleWP m_exe_module_wp;
 252     const uint32_t m_cu_idx;
 253 };
 254
 255 void
 256 SymbolFileDWARFDebugMap::Initialize()
 257 {
 258     PluginManager::RegisterPlugin (GetPluginNameStatic(),
 259                                    GetPluginDescriptionStatic(),
 260                                    CreateInstance);
 261 }
 262
 263 void
 264 SymbolFileDWARFDebugMap::Terminate()
 265 {
 266     PluginManager::UnregisterPlugin (CreateInstance);
 267 }
 268
 269
 270 lldb_private::ConstString
 271 SymbolFileDWARFDebugMap::GetPluginNameStatic()
 272 {
 273     static ConstString g_name("dwarf-debugmap");
 274     return g_name;
 275 }
 276
 277 const char *
 278 SymbolFileDWARFDebugMap::GetPluginDescriptionStatic()
 279 {
 280     return "DWARF and DWARF3 debug symbol file reader (debug map).";
 281 }
 282
 283 SymbolFile*
 284 SymbolFileDWARFDebugMap::CreateInstance (ObjectFile* obj_file)
 285 {
 286     return new SymbolFileDWARFDebugMap (obj_file);
 287 }
 288
 289
 290 SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap (ObjectFile* ofile) :
 291     SymbolFile(ofile),
 292     m_flags(),
 293     m_compile_unit_infos(),
 294     m_func_indexes(),
 295     m_glob_indexes(),
 296     m_supports_DW_AT_APPLE_objc_complete_type (eLazyBoolCalculate)
 297 {
 298 }
 299
 300
 301 SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap()
 302 {
 303 }
 304
 305 void
 306 SymbolFileDWARFDebugMap::InitializeObject()
 307 {
 308     // Install our external AST source callbacks so we can complete Clang types.
 309     llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_ap (
 310         new ClangExternalASTSourceCallbacks (SymbolFileDWARFDebugMap::CompleteTagDecl,
 311                                              SymbolFileDWARFDebugMap::CompleteObjCInterfaceDecl,
 312                                              NULL,
 313                                              SymbolFileDWARFDebugMap::LayoutRecordType,
 314                                              this));
 315
 316     GetClangASTContext().SetExternalSource (ast_source_ap);
 317 }
 318
 319 void
 320 SymbolFileDWARFDebugMap::InitOSO()
 321 {
 322     if (m_flags.test(kHaveInitializedOSOs))
 323         return;
 324
 325     m_flags.set(kHaveInitializedOSOs);
 326
 327     // If the object file has been stripped, there is no sense in looking further
 328     // as all of the debug symbols for the debug map will not be available
 329     if (m_obj_file->IsStripped())
 330         return;
 331
 332     // Also make sure the file type is some sort of executable. Core files, debug
 333     // info files (dSYM), object files (.o files), and stub libraries all can
 334     switch (m_obj_file->GetType())
 335     {
 336         case ObjectFile::eTypeInvalid:
 337         case ObjectFile::eTypeCoreFile:
 338         case ObjectFile::eTypeDebugInfo:
 339         case ObjectFile::eTypeObjectFile:
 340         case ObjectFile::eTypeStubLibrary:
 341         case ObjectFile::eTypeUnknown:
 342         case ObjectFile::eTypeJIT:
 343             return;
 344
 345         case ObjectFile::eTypeExecutable:
 346         case ObjectFile::eTypeDynamicLinker:
 347         case ObjectFile::eTypeSharedLibrary:
 348             break;
 349     }
 350
 351     // In order to get the abilities of this plug-in, we look at the list of
 352     // N_OSO entries (object files) from the symbol table and make sure that
 353     // these files exist and also contain valid DWARF. If we get any of that
 354     // then we return the abilities of the first N_OSO's DWARF.
 355
 356     Symtab* symtab = m_obj_file->GetSymtab();
 357     if (symtab)
 358     {
 359         Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP));
 360
 361         std::vector<uint32_t> oso_indexes;
 362         // When a mach-o symbol is encoded, the n_type field is encoded in bits
 363         // 23:16, and the n_desc field is encoded in bits 15:0.
 364         //
 365         // To find all N_OSO entries that are part of the DWARF + debug map
 366         // we find only object file symbols with the flags value as follows:
 367         // bits 23:16 == 0x66 (N_OSO)
 368         // bits 15: 0 == 0x0001 (specifies this is a debug map object file)
 369         const uint32_t k_oso_symbol_flags_value = 0x660001u;
 370
 371         const uint32_t oso_index_count = symtab->AppendSymbolIndexesWithTypeAndFlagsValue(eSymbolTypeObjectFile, k_oso_symbol_flags_value, oso_indexes);
 372
 373         if (oso_index_count > 0)
 374         {
 375             symtab->AppendSymbolIndexesWithType (eSymbolTypeCode, Symtab::eDebugYes, Symtab::eVisibilityAny, m_func_indexes);
 376             symtab->AppendSymbolIndexesWithType (eSymbolTypeData, Symtab::eDebugYes, Symtab::eVisibilityAny, m_glob_indexes);
 377
 378             symtab->SortSymbolIndexesByValue(m_func_indexes, true);
 379             symtab->SortSymbolIndexesByValue(m_glob_indexes, true);
 380
 381             for (uint32_t sym_idx : m_func_indexes)
 382             {
 383                 const Symbol *symbol = symtab->SymbolAtIndex(sym_idx);
 384                 lldb::addr_t file_addr = symbol->GetAddress().GetFileAddress();
 385                 lldb::addr_t byte_size = symbol->GetByteSize();
 386                 DebugMap::Entry debug_map_entry(file_addr, byte_size, OSOEntry(sym_idx, LLDB_INVALID_ADDRESS));
 387                 m_debug_map.Append(debug_map_entry);
 388             }
 389             for (uint32_t sym_idx : m_glob_indexes)
 390             {
 391                 const Symbol *symbol = symtab->SymbolAtIndex(sym_idx);
 392                 lldb::addr_t file_addr = symbol->GetAddress().GetFileAddress();
 393                 lldb::addr_t byte_size = symbol->GetByteSize();
 394                 DebugMap::Entry debug_map_entry(file_addr, byte_size, OSOEntry(sym_idx, LLDB_INVALID_ADDRESS));
 395                 m_debug_map.Append(debug_map_entry);
 396             }
 397             m_debug_map.Sort();
 398
 399             m_compile_unit_infos.resize(oso_index_count);
 400
 401             for (uint32_t i=0; i<oso_index_count; ++i)
 402             {
 403                 const uint32_t so_idx = oso_indexes[i] - 1;
 404                 const uint32_t oso_idx = oso_indexes[i];
 405                 const Symbol *so_symbol = symtab->SymbolAtIndex(so_idx);
 406                 const Symbol *oso_symbol = symtab->SymbolAtIndex(oso_idx);
 407                 if (so_symbol &&
 408                     oso_symbol &&
 409                     so_symbol->GetType() == eSymbolTypeSourceFile &&
 410                     oso_symbol->GetType() == eSymbolTypeObjectFile)
 411                 {
 412                     m_compile_unit_infos[i].so_file.SetFile(so_symbol->GetName().AsCString(), false);
 413                     m_compile_unit_infos[i].oso_path = oso_symbol->GetName();
 414                     TimeValue oso_mod_time;
 415                     oso_mod_time.OffsetWithSeconds(oso_symbol->GetAddress().GetOffset());
 416                     m_compile_unit_infos[i].oso_mod_time = oso_mod_time;
 417                     uint32_t sibling_idx = so_symbol->GetSiblingIndex();
 418                     // The sibling index can't be less that or equal to the current index "i"
 419                     if (sibling_idx <= i)
 420                     {
 421                         m_obj_file->GetModule()->ReportError ("N_SO in symbol with UID %u has invalid sibling in debug map, please file a bug and attach the binary listed in this error", so_symbol->GetID());
 422                     }
 423                     else
 424                     {
 425                         const Symbol* last_symbol = symtab->SymbolAtIndex (sibling_idx - 1);
 426                         m_compile_unit_infos[i].first_symbol_index = so_idx;
 427                         m_compile_unit_infos[i].last_symbol_index = sibling_idx - 1;
 428                         m_compile_unit_infos[i].first_symbol_id = so_symbol->GetID();
 429                         m_compile_unit_infos[i].last_symbol_id = last_symbol->GetID();
 430
 431                         if (log)
 432                             log->Printf("Initialized OSO 0x%8.8x: file=%s", i, oso_symbol->GetName().GetCString());
 433                     }
 434                 }
 435                 else
 436                 {
 437                     if (oso_symbol == NULL)
 438                         m_obj_file->GetModule()->ReportError ("N_OSO symbol[%u] can't be found, please file a bug and attach the binary listed in this error", oso_idx);
 439                     else if (so_symbol == NULL)
 440                         m_obj_file->GetModule()->ReportError ("N_SO not found for N_OSO symbol[%u], please file a bug and attach the binary listed in this error", oso_idx);
 441                     else if (so_symbol->GetType() != eSymbolTypeSourceFile)
 442                         m_obj_file->GetModule()->ReportError ("N_SO has incorrect symbol type (%u) for N_OSO symbol[%u], please file a bug and attach the binary listed in this error", so_symbol->GetType(), oso_idx);
 443                     else if (oso_symbol->GetType() != eSymbolTypeSourceFile)
 444                         m_obj_file->GetModule()->ReportError ("N_OSO has incorrect symbol type (%u) for N_OSO symbol[%u], please file a bug and attach the binary listed in this error", oso_symbol->GetType(), oso_idx);
 445                 }
 446             }
 447         }
 448     }
 449 }
 450
 451 Module *
 452 SymbolFileDWARFDebugMap::GetModuleByOSOIndex (uint32_t oso_idx)
 453 {
 454     const uint32_t cu_count = GetNumCompileUnits();
 455     if (oso_idx < cu_count)
 456         return GetModuleByCompUnitInfo (&m_compile_unit_infos[oso_idx]);
 457     return NULL;
 458 }
 459
 460 Module *
 461 SymbolFileDWARFDebugMap::GetModuleByCompUnitInfo (CompileUnitInfo *comp_unit_info)
 462 {
 463     if (!comp_unit_info->oso_sp)
 464     {
 465         auto pos = m_oso_map.find (comp_unit_info->oso_path);
 466         if (pos != m_oso_map.end())
 467         {
 468             comp_unit_info->oso_sp = pos->second;
 469         }
 470         else
 471         {
 472             ObjectFile *obj_file = GetObjectFile();
 473             comp_unit_info->oso_sp.reset (new OSOInfo());
 474             m_oso_map[comp_unit_info->oso_path] = comp_unit_info->oso_sp;
 475             const char *oso_path = comp_unit_info->oso_path.GetCString();
 476             FileSpec oso_file (oso_path, false);
 477             ConstString oso_object;
 478             if (oso_file.Exists())
 479             {
 480                 TimeValue oso_mod_time (oso_file.GetModificationTime());
 481                 if (oso_mod_time != comp_unit_info->oso_mod_time)
 482                 {
 483                     obj_file->GetModule()->ReportError ("debug map object file '%s' has changed (actual time is 0x%" PRIx64 ", debug map time is 0x%" PRIx64 ") since this executable was linked, file will be ignored",
 484                                                         oso_file.GetPath().c_str(),
 485                                                         oso_mod_time.GetAsSecondsSinceJan1_1970(),
 486                                                         comp_unit_info->oso_mod_time.GetAsSecondsSinceJan1_1970());
 487                     return NULL;
 488                 }
 489
 490             }
 491             else
 492             {
 493                 const bool must_exist = true;
 494
 495                 if (!ObjectFile::SplitArchivePathWithObject (oso_path,
 496                                                              oso_file,
 497                                                              oso_object,
 498                                                              must_exist))
 499                 {
 500                     return NULL;
 501                 }
 502             }
 503             // Always create a new module for .o files. Why? Because we
 504             // use the debug map, to add new sections to each .o file and
 505             // even though a .o file might not have changed, the sections
 506             // that get added to the .o file can change.
 507             ArchSpec oso_arch;
 508             // Only adopt the architecture from the module (not the vendor or OS)
 509             // since .o files for "i386-apple-ios" will historically show up as "i386-apple-macosx"
 510             // due to the lack of a LC_VERSION_MIN_MACOSX or LC_VERSION_MIN_IPHONEOS
 511             // load command...
 512             oso_arch.SetTriple(m_obj_file->GetModule()->GetArchitecture().GetTriple().getArchName().str().c_str());
 513             comp_unit_info->oso_sp->module_sp.reset (new DebugMapModule (obj_file->GetModule(),
 514                                                                          GetCompUnitInfoIndex(comp_unit_info),
 515                                                                          oso_file,
 516                                                                          oso_arch,
 517                                                                          oso_object ? &oso_object : NULL,
 518                                                                          0,
 519                                                                          oso_object ? &comp_unit_info->oso_mod_time : NULL));
 520         }
 521     }
 522     if (comp_unit_info->oso_sp)
 523         return comp_unit_info->oso_sp->module_sp.get();
 524     return NULL;
 525 }
 526
 527
 528 bool
 529 SymbolFileDWARFDebugMap::GetFileSpecForSO (uint32_t oso_idx, FileSpec &file_spec)
 530 {
 531     if (oso_idx < m_compile_unit_infos.size())
 532     {
 533         if (m_compile_unit_infos[oso_idx].so_file)
 534         {
 535             file_spec = m_compile_unit_infos[oso_idx].so_file;
 536             return true;
 537         }
 538     }
 539     return false;
 540 }
 541
 542
 543
 544 ObjectFile *
 545 SymbolFileDWARFDebugMap::GetObjectFileByOSOIndex (uint32_t oso_idx)
 546 {
 547     Module *oso_module = GetModuleByOSOIndex (oso_idx);
 548     if (oso_module)
 549         return oso_module->GetObjectFile();
 550     return NULL;
 551 }
 552
 553 SymbolFileDWARF *
 554 SymbolFileDWARFDebugMap::GetSymbolFile (const SymbolContext& sc)
 555 {
 556     CompileUnitInfo *comp_unit_info = GetCompUnitInfo (sc);
 557     if (comp_unit_info)
 558         return GetSymbolFileByCompUnitInfo (comp_unit_info);
 559     return NULL;
 560 }
 561
 562 ObjectFile *
 563 SymbolFileDWARFDebugMap::GetObjectFileByCompUnitInfo (CompileUnitInfo *comp_unit_info)
 564 {
 565     Module *oso_module = GetModuleByCompUnitInfo (comp_unit_info);
 566     if (oso_module)
 567         return oso_module->GetObjectFile();
 568     return NULL;
 569 }
 570
 571
 572 uint32_t
 573 SymbolFileDWARFDebugMap::GetCompUnitInfoIndex (const CompileUnitInfo *comp_unit_info)
 574 {
 575     if (!m_compile_unit_infos.empty())
 576     {
 577         const CompileUnitInfo *first_comp_unit_info = &m_compile_unit_infos.front();
 578         const CompileUnitInfo *last_comp_unit_info = &m_compile_unit_infos.back();
 579         if (first_comp_unit_info <= comp_unit_info && comp_unit_info <= last_comp_unit_info)
 580             return comp_unit_info - first_comp_unit_info;
 581     }
 582     return UINT32_MAX;
 583 }
 584
 585 SymbolFileDWARF *
 586 SymbolFileDWARFDebugMap::GetSymbolFileByOSOIndex (uint32_t oso_idx)
 587 {
 588     if (oso_idx < m_compile_unit_infos.size())
 589         return GetSymbolFileByCompUnitInfo (&m_compile_unit_infos[oso_idx]);
 590     return NULL;
 591 }
 592
 593 SymbolFileDWARF *
 594 SymbolFileDWARFDebugMap::GetSymbolFileAsSymbolFileDWARF (SymbolFile *sym_file)
 595 {
 596     if (sym_file && sym_file->GetPluginName() == SymbolFileDWARF::GetPluginNameStatic())
 597         return (SymbolFileDWARF *)sym_file;
 598     return NULL;
 599 }
 600
 601 SymbolFileDWARF *
 602 SymbolFileDWARFDebugMap::GetSymbolFileByCompUnitInfo (CompileUnitInfo *comp_unit_info)
 603 {
 604     Module *oso_module = GetModuleByCompUnitInfo (comp_unit_info);
 605     if (oso_module)
 606     {
 607         SymbolVendor *sym_vendor = oso_module->GetSymbolVendor();
 608         if (sym_vendor)
 609             return GetSymbolFileAsSymbolFileDWARF (sym_vendor->GetSymbolFile());
 610     }
 611     return NULL;
 612 }
 613
 614 uint32_t
 615 SymbolFileDWARFDebugMap::CalculateAbilities ()
 616 {
 617     // In order to get the abilities of this plug-in, we look at the list of
 618     // N_OSO entries (object files) from the symbol table and make sure that
 619     // these files exist and also contain valid DWARF. If we get any of that
 620     // then we return the abilities of the first N_OSO's DWARF.
 621
 622     const uint32_t oso_index_count = GetNumCompileUnits();
 623     if (oso_index_count > 0)
 624     {
 625         InitOSO();
 626         if (!m_compile_unit_infos.empty())
 627         {
 628             return SymbolFile::CompileUnits    |
 629                    SymbolFile::Functions       |
 630                    SymbolFile::Blocks          |
 631                    SymbolFile::GlobalVariables |
 632                    SymbolFile::LocalVariables  |
 633                    SymbolFile::VariableTypes   |
 634                    SymbolFile::LineTables      ;
 635         }
 636     }
 637     return 0;
 638 }
 639
 640 uint32_t
 641 SymbolFileDWARFDebugMap::GetNumCompileUnits()
 642 {
 643     InitOSO ();
 644     return m_compile_unit_infos.size();
 645 }
 646
 647
 648 CompUnitSP
 649 SymbolFileDWARFDebugMap::ParseCompileUnitAtIndex(uint32_t cu_idx)
 650 {
 651     CompUnitSP comp_unit_sp;
 652     const uint32_t cu_count = GetNumCompileUnits();
 653
 654     if (cu_idx < cu_count)
 655     {
 656         Module *oso_module = GetModuleByCompUnitInfo (&m_compile_unit_infos[cu_idx]);
 657         if (oso_module)
 658         {
 659             FileSpec so_file_spec;
 660             if (GetFileSpecForSO (cu_idx, so_file_spec))
 661             {
 662                 // User zero as the ID to match the compile unit at offset
 663                 // zero in each .o file since each .o file can only have
 664                 // one compile unit for now.
 665                 lldb::user_id_t cu_id = 0;
 666                 m_compile_unit_infos[cu_idx].compile_unit_sp.reset(new CompileUnit (m_obj_file->GetModule(),
 667                                                                                     NULL,
 668                                                                                     so_file_spec,
 669                                                                                     cu_id,
 670                                                                                     eLanguageTypeUnknown));
 671
 672                 if (m_compile_unit_infos[cu_idx].compile_unit_sp)
 673                 {
 674                     // Let our symbol vendor know about this compile unit
 675                     m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex (cu_idx, m_compile_unit_infos[cu_idx].compile_unit_sp);
 676                 }
 677             }
 678         }
 679         comp_unit_sp = m_compile_unit_infos[cu_idx].compile_unit_sp;
 680     }
 681
 682     return comp_unit_sp;
 683 }
 684
 685 SymbolFileDWARFDebugMap::CompileUnitInfo *
 686 SymbolFileDWARFDebugMap::GetCompUnitInfo (const SymbolContext& sc)
 687 {
 688     const uint32_t cu_count = GetNumCompileUnits();
 689     for (uint32_t i=0; i<cu_count; ++i)
 690     {
 691         if (sc.comp_unit == m_compile_unit_infos[i].compile_unit_sp.get())
 692             return &m_compile_unit_infos[i];
 693     }
 694     return NULL;
 695 }
 696
 697
 698 size_t
 699 SymbolFileDWARFDebugMap::GetCompUnitInfosForModule (const lldb_private::Module *module, std::vector<CompileUnitInfo *>& cu_infos)
 700 {
 701     const uint32_t cu_count = GetNumCompileUnits();
 702     for (uint32_t i=0; i<cu_count; ++i)
 703     {
 704         if (module == GetModuleByCompUnitInfo (&m_compile_unit_infos[i]))
 705             cu_infos.push_back (&m_compile_unit_infos[i]);
 706     }
 707     return cu_infos.size();
 708 }
 709
 710 lldb::LanguageType
 711 SymbolFileDWARFDebugMap::ParseCompileUnitLanguage (const SymbolContext& sc)
 712 {
 713     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
 714     if (oso_dwarf)
 715         return oso_dwarf->ParseCompileUnitLanguage (sc);
 716     return eLanguageTypeUnknown;
 717 }
 718
 719 size_t
 720 SymbolFileDWARFDebugMap::ParseCompileUnitFunctions (const SymbolContext& sc)
 721 {
 722     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
 723     if (oso_dwarf)
 724         return oso_dwarf->ParseCompileUnitFunctions (sc);
 725     return 0;
 726 }
 727
 728 bool
 729 SymbolFileDWARFDebugMap::ParseCompileUnitLineTable (const SymbolContext& sc)
 730 {
 731     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
 732     if (oso_dwarf)
 733         return oso_dwarf->ParseCompileUnitLineTable (sc);
 734     return false;
 735 }
 736
 737 bool
 738 SymbolFileDWARFDebugMap::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList &support_files)
 739 {
 740     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
 741     if (oso_dwarf)
 742         return oso_dwarf->ParseCompileUnitSupportFiles (sc, support_files);
 743     return false;
 744 }
 745
 746
 747 size_t
 748 SymbolFileDWARFDebugMap::ParseFunctionBlocks (const SymbolContext& sc)
 749 {
 750     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
 751     if (oso_dwarf)
 752         return oso_dwarf->ParseFunctionBlocks (sc);
 753     return 0;
 754 }
 755
 756
 757 size_t
 758 SymbolFileDWARFDebugMap::ParseTypes (const SymbolContext& sc)
 759 {
 760     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
 761     if (oso_dwarf)
 762         return oso_dwarf->ParseTypes (sc);
 763     return 0;
 764 }
 765
 766
 767 size_t
 768 SymbolFileDWARFDebugMap::ParseVariablesForContext (const SymbolContext& sc)
 769 {
 770     SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
 771     if (oso_dwarf)
 772         return oso_dwarf->ParseVariablesForContext (sc);
 773     return 0;
 774 }
 775
 776
 777
 778 Type*
 779 SymbolFileDWARFDebugMap::ResolveTypeUID(lldb::user_id_t type_uid)
 780 {
 781     const uint64_t oso_idx = GetOSOIndexFromUserID (type_uid);
 782     SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
 783     if (oso_dwarf)
 784         return oso_dwarf->ResolveTypeUID (type_uid);
 785     return NULL;
 786 }
 787
 788 bool
 789 SymbolFileDWARFDebugMap::ResolveClangOpaqueTypeDefinition (ClangASTType& clang_type)
 790 {
 791     // We have a struct/union/class/enum that needs to be fully resolved.
 792     return false;
 793 }
 794
 795 uint32_t
 796 SymbolFileDWARFDebugMap::ResolveSymbolContext (const Address& exe_so_addr, uint32_t resolve_scope, SymbolContext& sc)
 797 {
 798     uint32_t resolved_flags = 0;
 799     Symtab* symtab = m_obj_file->GetSymtab();
 800     if (symtab)
 801     {
 802         const addr_t exe_file_addr = exe_so_addr.GetFileAddress();
 803
 804         const DebugMap::Entry *debug_map_entry = m_debug_map.FindEntryThatContains (exe_file_addr);
 805         if (debug_map_entry)
 806         {
 807
 808             sc.symbol = symtab->SymbolAtIndex(debug_map_entry->data.GetExeSymbolIndex());
 809
 810             if (sc.symbol != NULL)
 811             {
 812                 resolved_flags |= eSymbolContextSymbol;
 813
 814                 uint32_t oso_idx = 0;
 815                 CompileUnitInfo* comp_unit_info = GetCompileUnitInfoForSymbolWithID (sc.symbol->GetID(), &oso_idx);
 816                 if (comp_unit_info)
 817                 {
 818                     comp_unit_info->GetFileRangeMap(this);
 819                     Module *oso_module = GetModuleByCompUnitInfo (comp_unit_info);
 820                     if (oso_module)
 821                     {
 822                         lldb::addr_t oso_file_addr = exe_file_addr - debug_map_entry->GetRangeBase() + debug_map_entry->data.GetOSOFileAddress();
 823                         Address oso_so_addr;
 824                         if (oso_module->ResolveFileAddress(oso_file_addr, oso_so_addr))
 825                         {
 826                             resolved_flags |= oso_module->GetSymbolVendor()->ResolveSymbolContext (oso_so_addr, resolve_scope, sc);
 827                         }
 828                     }
 829                 }
 830             }
 831         }
 832     }
 833     return resolved_flags;
 834 }
 835
 836
 837 uint32_t
 838 SymbolFileDWARFDebugMap::ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
 839 {
 840     const uint32_t initial = sc_list.GetSize();
 841     const uint32_t cu_count = GetNumCompileUnits();
 842
 843     for (uint32_t i=0; i<cu_count; ++i)
 844     {
 845         // If we are checking for inlines, then we need to look through all
 846         // compile units no matter if "file_spec" matches.
 847         bool resolve = check_inlines;
 848
 849         if (!resolve)
 850         {
 851             FileSpec so_file_spec;
 852             if (GetFileSpecForSO (i, so_file_spec))
 853             {
 854                 // Match the full path if the incoming file_spec has a directory (not just a basename)
 855                 const bool full_match = (bool)file_spec.GetDirectory();
 856                 resolve = FileSpec::Equal (file_spec, so_file_spec, full_match);
 857             }
 858         }
 859         if (resolve)
 860         {
 861             SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (i);
 862             if (oso_dwarf)
 863                 oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope, sc_list);
 864         }
 865     }
 866     return sc_list.GetSize() - initial;
 867 }
 868
 869 uint32_t
 870 SymbolFileDWARFDebugMap::PrivateFindGlobalVariables
 871 (
 872     const ConstString &name,
 873     const ClangNamespaceDecl *namespace_decl,
 874     const std::vector<uint32_t> &indexes,   // Indexes into the symbol table that match "name"
 875     uint32_t max_matches,
 876     VariableList& variables
 877 )
 878 {
 879     const uint32_t original_size = variables.GetSize();
 880     const size_t match_count = indexes.size();
 881     for (size_t i=0; i<match_count; ++i)
 882     {
 883         uint32_t oso_idx;
 884         CompileUnitInfo* comp_unit_info = GetCompileUnitInfoForSymbolWithIndex (indexes[i], &oso_idx);
 885         if (comp_unit_info)
 886         {
 887             SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
 888             if (oso_dwarf)
 889             {
 890                 if (oso_dwarf->FindGlobalVariables(name, namespace_decl, true, max_matches, variables))
 891                     if (variables.GetSize() > max_matches)
 892                         break;
 893             }
 894         }
 895     }
 896     return variables.GetSize() - original_size;
 897 }
 898
 899 uint32_t
 900 SymbolFileDWARFDebugMap::FindGlobalVariables (const ConstString &name, const ClangNamespaceDecl *namespace_decl, bool append, uint32_t max_matches, VariableList& variables)
 901 {
 902
 903     // If we aren't appending the results to this list, then clear the list
 904     if (!append)
 905         variables.Clear();
 906
 907     // Remember how many variables are in the list before we search in case
 908     // we are appending the results to a variable list.
 909     const uint32_t original_size = variables.GetSize();
 910
 911     uint32_t total_matches = 0;
 912     SymbolFileDWARF *oso_dwarf;
 913     for (uint32_t oso_idx = 0; ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
 914     {
 915         const uint32_t oso_matches = oso_dwarf->FindGlobalVariables (name,
 916                                                                      namespace_decl,
 917                                                                      true,
 918                                                                      max_matches,
 919                                                                      variables);
 920         if (oso_matches > 0)
 921         {
 922             total_matches += oso_matches;
 923
 924             // Are we getting all matches?
 925             if (max_matches == UINT32_MAX)
 926                 continue;   // Yep, continue getting everything
 927
 928             // If we have found enough matches, lets get out
 929             if (max_matches >= total_matches)
 930                 break;
 931
 932             // Update the max matches for any subsequent calls to find globals
 933             // in any other object files with DWARF
 934             max_matches -= oso_matches;
 935         }
 936     }
 937     // Return the number of variable that were appended to the list
 938     return variables.GetSize() - original_size;
 939 }
 940
 941
 942 uint32_t
 943 SymbolFileDWARFDebugMap::FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables)
 944 {
 945     // If we aren't appending the results to this list, then clear the list
 946     if (!append)
 947         variables.Clear();
 948
 949     // Remember how many variables are in the list before we search in case
 950     // we are appending the results to a variable list.
 951     const uint32_t original_size = variables.GetSize();
 952
 953     uint32_t total_matches = 0;
 954     SymbolFileDWARF *oso_dwarf;
 955     for (uint32_t oso_idx = 0; ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
 956     {
 957         const uint32_t oso_matches = oso_dwarf->FindGlobalVariables (regex,
 958                                                                      true,
 959                                                                      max_matches,
 960                                                                      variables);
 961         if (oso_matches > 0)
 962         {
 963             total_matches += oso_matches;
 964
 965             // Are we getting all matches?
 966             if (max_matches == UINT32_MAX)
 967                 continue;   // Yep, continue getting everything
 968
 969             // If we have found enough matches, lets get out
 970             if (max_matches >= total_matches)
 971                 break;
 972
 973             // Update the max matches for any subsequent calls to find globals
 974             // in any other object files with DWARF
 975             max_matches -= oso_matches;
 976         }
 977     }
 978     // Return the number of variable that were appended to the list
 979     return variables.GetSize() - original_size;
 980 }
 981
 982
 983 int
 984 SymbolFileDWARFDebugMap::SymbolContainsSymbolWithIndex (uint32_t *symbol_idx_ptr, const CompileUnitInfo *comp_unit_info)
 985 {
 986     const uint32_t symbol_idx = *symbol_idx_ptr;
 987
 988     if (symbol_idx < comp_unit_info->first_symbol_index)
 989         return -1;
 990
 991     if (symbol_idx <= comp_unit_info->last_symbol_index)
 992         return 0;
 993
 994     return 1;
 995 }
 996
 997
 998 int
 999 SymbolFileDWARFDebugMap::SymbolContainsSymbolWithID (user_id_t *symbol_idx_ptr, const CompileUnitInfo *comp_unit_info)
1000 {
1001     const user_id_t symbol_id = *symbol_idx_ptr;
1002
1003     if (symbol_id < comp_unit_info->first_symbol_id)
1004         return -1;
1005
1006     if (symbol_id <= comp_unit_info->last_symbol_id)
1007         return 0;
1008
1009     return 1;
1010 }
1011
1012
1013 SymbolFileDWARFDebugMap::CompileUnitInfo*
1014 SymbolFileDWARFDebugMap::GetCompileUnitInfoForSymbolWithIndex (uint32_t symbol_idx, uint32_t *oso_idx_ptr)
1015 {
1016     const uint32_t oso_index_count = m_compile_unit_infos.size();
1017     CompileUnitInfo *comp_unit_info = NULL;
1018     if (oso_index_count)
1019     {
1020         comp_unit_info = (CompileUnitInfo*)bsearch(&symbol_idx,
1021                                                    &m_compile_unit_infos[0],
1022                                                    m_compile_unit_infos.size(),
1023                                                    sizeof(CompileUnitInfo),
1024                                                    (ComparisonFunction)SymbolContainsSymbolWithIndex);
1025     }
1026
1027     if (oso_idx_ptr)
1028     {
1029         if (comp_unit_info != NULL)
1030             *oso_idx_ptr = comp_unit_info - &m_compile_unit_infos[0];
1031         else
1032             *oso_idx_ptr = UINT32_MAX;
1033     }
1034     return comp_unit_info;
1035 }
1036
1037 SymbolFileDWARFDebugMap::CompileUnitInfo*
1038 SymbolFileDWARFDebugMap::GetCompileUnitInfoForSymbolWithID (user_id_t symbol_id, uint32_t *oso_idx_ptr)
1039 {
1040     const uint32_t oso_index_count = m_compile_unit_infos.size();
1041     CompileUnitInfo *comp_unit_info = NULL;
1042     if (oso_index_count)
1043     {
1044         comp_unit_info = (CompileUnitInfo*)::bsearch (&symbol_id,
1045                                                       &m_compile_unit_infos[0],
1046                                                       m_compile_unit_infos.size(),
1047                                                       sizeof(CompileUnitInfo),
1048                                                       (ComparisonFunction)SymbolContainsSymbolWithID);
1049     }
1050
1051     if (oso_idx_ptr)
1052     {
1053         if (comp_unit_info != NULL)
1054             *oso_idx_ptr = comp_unit_info - &m_compile_unit_infos[0];
1055         else
1056             *oso_idx_ptr = UINT32_MAX;
1057     }
1058     return comp_unit_info;
1059 }
1060
1061
1062 static void
1063 RemoveFunctionsWithModuleNotEqualTo (const ModuleSP &module_sp, SymbolContextList &sc_list, uint32_t start_idx)
1064 {
1065     // We found functions in .o files. Not all functions in the .o files
1066     // will have made it into the final output file. The ones that did
1067     // make it into the final output file will have a section whose module
1068     // matches the module from the ObjectFile for this SymbolFile. When
1069     // the modules don't match, then we have something that was in a
1070     // .o file, but doesn't map to anything in the final executable.
1071     uint32_t i=start_idx;
1072     while (i < sc_list.GetSize())
1073     {
1074         SymbolContext sc;
1075         sc_list.GetContextAtIndex(i, sc);
1076         if (sc.function)
1077         {
1078             const SectionSP section_sp (sc.function->GetAddressRange().GetBaseAddress().GetSection());
1079             if (section_sp->GetModule() != module_sp)
1080             {
1081                 sc_list.RemoveContextAtIndex(i);
1082                 continue;
1083             }
1084         }
1085         ++i;
1086     }
1087 }
1088
1089 uint32_t
1090 SymbolFileDWARFDebugMap::FindFunctions(const ConstString &name, const ClangNamespaceDecl *namespace_decl, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list)
1091 {
1092     Timer scoped_timer (__PRETTY_FUNCTION__,
1093                         "SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
1094                         name.GetCString());
1095
1096     uint32_t initial_size = 0;
1097     if (append)
1098         initial_size = sc_list.GetSize();
1099     else
1100         sc_list.Clear();
1101
1102     uint32_t oso_idx = 0;
1103     SymbolFileDWARF *oso_dwarf;
1104     while ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx++)) != NULL)
1105     {
1106         uint32_t sc_idx = sc_list.GetSize();
1107         if (oso_dwarf->FindFunctions(name, namespace_decl, name_type_mask, include_inlines, true, sc_list))
1108         {
1109             RemoveFunctionsWithModuleNotEqualTo (m_obj_file->GetModule(), sc_list, sc_idx);
1110         }
1111     }
1112
1113     return sc_list.GetSize() - initial_size;
1114 }
1115
1116
1117 uint32_t
1118 SymbolFileDWARFDebugMap::FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list)
1119 {
1120     Timer scoped_timer (__PRETTY_FUNCTION__,
1121                         "SymbolFileDWARFDebugMap::FindFunctions (regex = '%s')",
1122                         regex.GetText());
1123
1124     uint32_t initial_size = 0;
1125     if (append)
1126         initial_size = sc_list.GetSize();
1127     else
1128         sc_list.Clear();
1129
1130     uint32_t oso_idx = 0;
1131     SymbolFileDWARF *oso_dwarf;
1132     while ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx++)) != NULL)
1133     {
1134         uint32_t sc_idx = sc_list.GetSize();
1135
1136         if (oso_dwarf->FindFunctions(regex, include_inlines, true, sc_list))
1137         {
1138             RemoveFunctionsWithModuleNotEqualTo (m_obj_file->GetModule(), sc_list, sc_idx);
1139         }
1140     }
1141
1142     return sc_list.GetSize() - initial_size;
1143 }
1144
1145 size_t
1146 SymbolFileDWARFDebugMap::GetTypes (SymbolContextScope *sc_scope,
1147                                    uint32_t type_mask,
1148                                    TypeList &type_list)
1149 {
1150     Timer scoped_timer (__PRETTY_FUNCTION__,
1151                         "SymbolFileDWARFDebugMap::GetTypes (type_mask = 0x%8.8x)",
1152                         type_mask);
1153
1154
1155     uint32_t initial_size = type_list.GetSize();
1156     SymbolFileDWARF *oso_dwarf = NULL;
1157     if (sc_scope)
1158     {
1159         SymbolContext sc;
1160         sc_scope->CalculateSymbolContext(&sc);
1161
1162         CompileUnitInfo *cu_info = GetCompUnitInfo (sc);
1163         if (cu_info)
1164         {
1165             oso_dwarf = GetSymbolFileByCompUnitInfo (cu_info);
1166             if (oso_dwarf)
1167                 oso_dwarf->GetTypes (sc_scope, type_mask, type_list);
1168         }
1169     }
1170     else
1171     {
1172         uint32_t oso_idx = 0;
1173         while ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx++)) != NULL)
1174         {
1175             oso_dwarf->GetTypes (sc_scope, type_mask, type_list);
1176         }
1177     }
1178     return type_list.GetSize() - initial_size;
1179 }
1180
1181
1182 TypeSP
1183 SymbolFileDWARFDebugMap::FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &die_decl_ctx)
1184 {
1185     TypeSP type_sp;
1186     SymbolFileDWARF *oso_dwarf;
1187     for (uint32_t oso_idx = 0; ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
1188     {
1189         type_sp = oso_dwarf->FindDefinitionTypeForDWARFDeclContext (die_decl_ctx);
1190         if (type_sp)
1191             break;
1192     }
1193     return type_sp;
1194 }
1195
1196
1197
1198 bool
1199 SymbolFileDWARFDebugMap::Supports_DW_AT_APPLE_objc_complete_type (SymbolFileDWARF *skip_dwarf_oso)
1200 {
1201     if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate)
1202     {
1203         m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo;
1204         SymbolFileDWARF *oso_dwarf;
1205         for (uint32_t oso_idx = 0; ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
1206         {
1207             if (skip_dwarf_oso != oso_dwarf && oso_dwarf->Supports_DW_AT_APPLE_objc_complete_type(NULL))
1208             {
1209                 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
1210                 break;
1211             }
1212         }
1213     }
1214     return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
1215 }
1216
1217 TypeSP
1218 SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE (const DWARFDebugInfoEntry *die,
1219                                                                const ConstString &type_name,
1220                                                                bool must_be_implementation)
1221 {
1222     TypeSP type_sp;
1223     SymbolFileDWARF *oso_dwarf;
1224     for (uint32_t oso_idx = 0; ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
1225     {
1226         type_sp = oso_dwarf->FindCompleteObjCDefinitionTypeForDIE (die, type_name, must_be_implementation);
1227         if (type_sp)
1228             break;
1229     }
1230     return type_sp;
1231 }
1232
1233 uint32_t
1234 SymbolFileDWARFDebugMap::FindTypes
1235 (
1236     const SymbolContext& sc,
1237     const ConstString &name,
1238     const ClangNamespaceDecl *namespace_decl,
1239     bool append,
1240     uint32_t max_matches,
1241     TypeList& types
1242 )
1243 {
1244     if (!append)
1245         types.Clear();
1246
1247     const uint32_t initial_types_size = types.GetSize();
1248     SymbolFileDWARF *oso_dwarf;
1249
1250     if (sc.comp_unit)
1251     {
1252         oso_dwarf = GetSymbolFile (sc);
1253         if (oso_dwarf)
1254             return oso_dwarf->FindTypes (sc, name, namespace_decl, append, max_matches, types);
1255     }
1256     else
1257     {
1258         uint32_t oso_idx = 0;
1259         while ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx++)) != NULL)
1260             oso_dwarf->FindTypes (sc, name, namespace_decl, append, max_matches, types);
1261     }
1262
1263     return types.GetSize() - initial_types_size;
1264 }
1265
1266 //
1267 //uint32_t
1268 //SymbolFileDWARFDebugMap::FindTypes (const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, Type::Encoding encoding, lldb::user_id_t udt_uid, TypeList& types)
1269 //{
1270 //  SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
1271 //  if (oso_dwarf)
1272 //      return oso_dwarf->FindTypes (sc, regex, append, max_matches, encoding, udt_uid, types);
1273 //  return 0;
1274 //}
1275
1276
1277 ClangNamespaceDecl
1278 SymbolFileDWARFDebugMap::FindNamespace (const lldb_private::SymbolContext& sc,
1279                                         const lldb_private::ConstString &name,
1280                                         const ClangNamespaceDecl *parent_namespace_decl)
1281 {
1282     ClangNamespaceDecl matching_namespace;
1283     SymbolFileDWARF *oso_dwarf;
1284
1285     if (sc.comp_unit)
1286     {
1287         oso_dwarf = GetSymbolFile (sc);
1288         if (oso_dwarf)
1289             matching_namespace = oso_dwarf->FindNamespace (sc, name, parent_namespace_decl);
1290     }
1291     else
1292     {
1293         for (uint32_t oso_idx = 0;
1294              ((oso_dwarf = GetSymbolFileByOSOIndex (oso_idx)) != NULL);
1295              ++oso_idx)
1296         {
1297             matching_namespace = oso_dwarf->FindNamespace (sc, name, parent_namespace_decl);
1298
1299             if (matching_namespace)
1300                 break;
1301         }
1302     }
1303
1304     return matching_namespace;
1305 }
1306
1307 //------------------------------------------------------------------
1308 // PluginInterface protocol
1309 //------------------------------------------------------------------
1310 lldb_private::ConstString
1311 SymbolFileDWARFDebugMap::GetPluginName()
1312 {
1313     return GetPluginNameStatic();
1314 }
1315
1316 uint32_t
1317 SymbolFileDWARFDebugMap::GetPluginVersion()
1318 {
1319     return 1;
1320 }
1321
1322 lldb::CompUnitSP
1323 SymbolFileDWARFDebugMap::GetCompileUnit (SymbolFileDWARF *oso_dwarf)
1324 {
1325     if (oso_dwarf)
1326     {
1327         const uint32_t cu_count = GetNumCompileUnits();
1328         for (uint32_t cu_idx=0; cu_idx<cu_count; ++cu_idx)
1329         {
1330             SymbolFileDWARF *oso_symfile = GetSymbolFileByCompUnitInfo (&m_compile_unit_infos[cu_idx]);
1331             if (oso_symfile == oso_dwarf)
1332             {
1333                 if (!m_compile_unit_infos[cu_idx].compile_unit_sp)
1334                     m_compile_unit_infos[cu_idx].compile_unit_sp = ParseCompileUnitAtIndex (cu_idx);
1335
1336                 return m_compile_unit_infos[cu_idx].compile_unit_sp;
1337             }
1338         }
1339     }
1340     assert(!"this shouldn't happen");
1341     return lldb::CompUnitSP();
1342 }
1343
1344 SymbolFileDWARFDebugMap::CompileUnitInfo *
1345 SymbolFileDWARFDebugMap::GetCompileUnitInfo (SymbolFileDWARF *oso_dwarf)
1346 {
1347     if (oso_dwarf)
1348     {
1349         const uint32_t cu_count = GetNumCompileUnits();
1350         for (uint32_t cu_idx=0; cu_idx<cu_count; ++cu_idx)
1351         {
1352             SymbolFileDWARF *oso_symfile = GetSymbolFileByCompUnitInfo (&m_compile_unit_infos[cu_idx]);
1353             if (oso_symfile == oso_dwarf)
1354             {
1355                 return &m_compile_unit_infos[cu_idx];
1356             }
1357         }
1358     }
1359     return NULL;
1360 }
1361
1362
1363 void
1364 SymbolFileDWARFDebugMap::SetCompileUnit (SymbolFileDWARF *oso_dwarf, const CompUnitSP &cu_sp)
1365 {
1366     if (oso_dwarf)
1367     {
1368         const uint32_t cu_count = GetNumCompileUnits();
1369         for (uint32_t cu_idx=0; cu_idx<cu_count; ++cu_idx)
1370         {
1371             SymbolFileDWARF *oso_symfile = GetSymbolFileByCompUnitInfo (&m_compile_unit_infos[cu_idx]);
1372             if (oso_symfile == oso_dwarf)
1373             {
1374                 if (m_compile_unit_infos[cu_idx].compile_unit_sp)
1375                 {
1376                     assert (m_compile_unit_infos[cu_idx].compile_unit_sp.get() == cu_sp.get());
1377                 }
1378                 else
1379                 {
1380                     m_compile_unit_infos[cu_idx].compile_unit_sp = cu_sp;
1381                     m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(cu_idx, cu_sp);
1382                 }
1383             }
1384         }
1385     }
1386 }
1387
1388
1389 void
1390 SymbolFileDWARFDebugMap::CompleteTagDecl (void *baton, clang::TagDecl *decl)
1391 {
1392     SymbolFileDWARFDebugMap *symbol_file_dwarf = (SymbolFileDWARFDebugMap *)baton;
1393     ClangASTType clang_type = symbol_file_dwarf->GetClangASTContext().GetTypeForDecl (decl);
1394     if (clang_type)
1395     {
1396         SymbolFileDWARF *oso_dwarf;
1397
1398         for (uint32_t oso_idx = 0; ((oso_dwarf = symbol_file_dwarf->GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
1399         {
1400             if (oso_dwarf->HasForwardDeclForClangType (clang_type))
1401             {
1402                 oso_dwarf->ResolveClangOpaqueTypeDefinition (clang_type);
1403                 return;
1404             }
1405         }
1406     }
1407 }
1408
1409 void
1410 SymbolFileDWARFDebugMap::CompleteObjCInterfaceDecl (void *baton, clang::ObjCInterfaceDecl *decl)
1411 {
1412     SymbolFileDWARFDebugMap *symbol_file_dwarf = (SymbolFileDWARFDebugMap *)baton;
1413     ClangASTType clang_type = symbol_file_dwarf->GetClangASTContext().GetTypeForDecl (decl);
1414     if (clang_type)
1415     {
1416         SymbolFileDWARF *oso_dwarf;
1417
1418         for (uint32_t oso_idx = 0; ((oso_dwarf = symbol_file_dwarf->GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
1419         {
1420             if (oso_dwarf->HasForwardDeclForClangType (clang_type))
1421             {
1422                 oso_dwarf->ResolveClangOpaqueTypeDefinition (clang_type);
1423                 return;
1424             }
1425         }
1426     }
1427 }
1428
1429 bool
1430 SymbolFileDWARFDebugMap::LayoutRecordType (void *baton,
1431                                            const clang::RecordDecl *record_decl,
1432                                            uint64_t &size,
1433                                            uint64_t &alignment,
1434                                            llvm::DenseMap <const clang::FieldDecl *, uint64_t> &field_offsets,
1435                                            llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
1436                                            llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets)
1437 {
1438     SymbolFileDWARFDebugMap *symbol_file_dwarf = (SymbolFileDWARFDebugMap *)baton;
1439     SymbolFileDWARF *oso_dwarf;
1440     for (uint32_t oso_idx = 0; ((oso_dwarf = symbol_file_dwarf->GetSymbolFileByOSOIndex (oso_idx)) != NULL); ++oso_idx)
1441     {
1442         if (oso_dwarf->LayoutRecordType (record_decl, size, alignment, field_offsets, base_offsets, vbase_offsets))
1443             return true;
1444     }
1445     return false;
1446 }
1447
1448
1449
1450 clang::DeclContext*
1451 SymbolFileDWARFDebugMap::GetClangDeclContextContainingTypeUID (lldb::user_id_t type_uid)
1452 {
1453     const uint64_t oso_idx = GetOSOIndexFromUserID (type_uid);
1454     SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
1455     if (oso_dwarf)
1456         return oso_dwarf->GetClangDeclContextContainingTypeUID (type_uid);
1457     return NULL;
1458 }
1459
1460 clang::DeclContext*
1461 SymbolFileDWARFDebugMap::GetClangDeclContextForTypeUID (const lldb_private::SymbolContext &sc, lldb::user_id_t type_uid)
1462 {
1463     const uint64_t oso_idx = GetOSOIndexFromUserID (type_uid);
1464     SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
1465     if (oso_dwarf)
1466         return oso_dwarf->GetClangDeclContextForTypeUID (sc, type_uid);
1467     return NULL;
1468 }
1469
1470 bool
1471 SymbolFileDWARFDebugMap::AddOSOFileRange (CompileUnitInfo *cu_info,
1472                                           lldb::addr_t exe_file_addr,
1473                                           lldb::addr_t oso_file_addr,
1474                                           lldb::addr_t oso_byte_size)
1475 {
1476     const uint32_t debug_map_idx = m_debug_map.FindEntryIndexThatContains(exe_file_addr);
1477     if (debug_map_idx != UINT32_MAX)
1478     {
1479         DebugMap::Entry *debug_map_entry = m_debug_map.FindEntryThatContains(exe_file_addr);
1480         debug_map_entry->data.SetOSOFileAddress(oso_file_addr);
1481         cu_info->file_range_map.Append(FileRangeMap::Entry(oso_file_addr, oso_byte_size, exe_file_addr));
1482         return true;
1483     }
1484     return false;
1485 }
1486
1487 void
1488 SymbolFileDWARFDebugMap::FinalizeOSOFileRanges (CompileUnitInfo *cu_info)
1489 {
1490     cu_info->file_range_map.Sort();
1491 #if defined(DEBUG_OSO_DMAP)
1492     const FileRangeMap &oso_file_range_map = cu_info->GetFileRangeMap(this);
1493     const size_t n = oso_file_range_map.GetSize();
1494     printf ("SymbolFileDWARFDebugMap::FinalizeOSOFileRanges (cu_info = %p) %s\n",
1495             cu_info,
1496             cu_info->oso_sp->module_sp->GetFileSpec().GetPath().c_str());
1497     for (size_t i=0; i<n; ++i)
1498     {
1499         const FileRangeMap::Entry &entry = oso_file_range_map.GetEntryRef(i);
1500         printf ("oso [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 ") ==> exe [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 ")\n",
1501                 entry.GetRangeBase(), entry.GetRangeEnd(),
1502                 entry.data, entry.data + entry.GetByteSize());
1503     }
1504 #endif
1505 }
1506
1507 lldb::addr_t
1508 SymbolFileDWARFDebugMap::LinkOSOFileAddress (SymbolFileDWARF *oso_symfile, lldb::addr_t oso_file_addr)
1509 {
1510     CompileUnitInfo *cu_info = GetCompileUnitInfo (oso_symfile);
1511     if (cu_info)
1512     {
1513         const FileRangeMap::Entry *oso_range_entry = cu_info->GetFileRangeMap(this).FindEntryThatContains(oso_file_addr);
1514         if (oso_range_entry)
1515         {
1516             const DebugMap::Entry *debug_map_entry = m_debug_map.FindEntryThatContains(oso_range_entry->data);
1517             if (debug_map_entry)
1518             {
1519                 const lldb::addr_t offset = oso_file_addr - oso_range_entry->GetRangeBase();
1520                 const lldb::addr_t exe_file_addr = debug_map_entry->GetRangeBase() + offset;
1521                 return exe_file_addr;
1522             }
1523         }
1524     }
1525     return LLDB_INVALID_ADDRESS;
1526 }
1527
1528 bool
1529 SymbolFileDWARFDebugMap::LinkOSOAddress (Address &addr)
1530 {
1531     // Make sure this address hasn't been fixed already
1532     Module *exe_module = GetObjectFile()->GetModule().get();
1533     Module *addr_module = addr.GetModule().get();
1534     if (addr_module == exe_module)
1535         return true; // Address is already in terms of the main executable module
1536
1537     CompileUnitInfo *cu_info = GetCompileUnitInfo (GetSymbolFileAsSymbolFileDWARF(addr_module->GetSymbolVendor()->GetSymbolFile()));
1538     if (cu_info)
1539     {
1540         const lldb::addr_t oso_file_addr = addr.GetFileAddress();
1541         const FileRangeMap::Entry *oso_range_entry = cu_info->GetFileRangeMap(this).FindEntryThatContains(oso_file_addr);
1542         if (oso_range_entry)
1543         {
1544             const DebugMap::Entry *debug_map_entry = m_debug_map.FindEntryThatContains(oso_range_entry->data);
1545             if (debug_map_entry)
1546             {
1547                 const lldb::addr_t offset = oso_file_addr - oso_range_entry->GetRangeBase();
1548                 const lldb::addr_t exe_file_addr = debug_map_entry->GetRangeBase() + offset;
1549                 return exe_module->ResolveFileAddress(exe_file_addr, addr);
1550             }
1551         }
1552     }
1553     return true;
1554 }
1555
1556 LineTable *
1557 SymbolFileDWARFDebugMap::LinkOSOLineTable (SymbolFileDWARF *oso_dwarf, LineTable *line_table)
1558 {
1559     CompileUnitInfo *cu_info = GetCompileUnitInfo (oso_dwarf);
1560     if (cu_info)
1561         return line_table->LinkLineTable(cu_info->GetFileRangeMap(this));
1562     return NULL;
1563 }
1564
1565 size_t
1566 SymbolFileDWARFDebugMap::AddOSOARanges (SymbolFileDWARF* dwarf2Data, DWARFDebugAranges* debug_aranges)
1567 {
1568     size_t num_line_entries_added = 0;
1569     if (debug_aranges && dwarf2Data)
1570     {
1571         CompileUnitInfo *compile_unit_info = GetCompileUnitInfo(dwarf2Data);
1572         if (compile_unit_info)
1573         {
1574             const FileRangeMap &file_range_map = compile_unit_info->GetFileRangeMap(this);
1575             for (size_t idx = 0;
1576                  idx < file_range_map.GetSize();
1577                  idx++)
1578             {
1579                 const FileRangeMap::Entry* entry = file_range_map.GetEntryAtIndex(idx);
1580                 if (entry)
1581                 {
1582                     printf ("[0x%16.16" PRIx64 " - 0x%16.16" PRIx64 ")\n", entry->GetRangeBase(), entry->GetRangeEnd());
1583                     debug_aranges->AppendRange(dwarf2Data->GetID(), entry->GetRangeBase(), entry->GetRangeEnd());
1584                     num_line_entries_added++;
1585                 }
1586             }
1587         }
1588     }
1589     return num_line_entries_added;
1590 }
1591