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

   1 //===-- DWARFDebugInfo.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 "SymbolFileDWARF.h"
  11
  12 #include <algorithm>
  13 #include <set>
  14
  15 #include "lldb/Core/RegularExpression.h"
  16 #include "lldb/Core/Stream.h"
  17 #include "lldb/Symbol/ObjectFile.h"
  18
  19 #include "DWARFDebugAranges.h"
  20 #include "DWARFDebugInfo.h"
  21 #include "DWARFCompileUnit.h"
  22 #include "DWARFDebugAranges.h"
  23 #include "DWARFDebugInfoEntry.h"
  24 #include "DWARFFormValue.h"
  25 #include "LogChannelDWARF.h"
  26
  27 using namespace lldb;
  28 using namespace lldb_private;
  29 using namespace std;
  30
  31 //----------------------------------------------------------------------
  32 // Constructor
  33 //----------------------------------------------------------------------
  34 DWARFDebugInfo::DWARFDebugInfo() :
  35     m_dwarf2Data(NULL),
  36     m_compile_units(),
  37     m_cu_aranges_ap ()
  38 {
  39 }
  40
  41 //----------------------------------------------------------------------
  42 // SetDwarfData
  43 //----------------------------------------------------------------------
  44 void
  45 DWARFDebugInfo::SetDwarfData(SymbolFileDWARF* dwarf2Data)
  46 {
  47     m_dwarf2Data = dwarf2Data;
  48     m_compile_units.clear();
  49 }
  50
  51
  52 DWARFDebugAranges &
  53 DWARFDebugInfo::GetCompileUnitAranges ()
  54 {
  55     if (m_cu_aranges_ap.get() == NULL && m_dwarf2Data)
  56     {
  57         Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_ARANGES));
  58
  59         m_cu_aranges_ap.reset (new DWARFDebugAranges());
  60         const DataExtractor &debug_aranges_data = m_dwarf2Data->get_debug_aranges_data();
  61         if (debug_aranges_data.GetByteSize() > 0)
  62         {
  63             if (log)
  64                 log->Printf ("DWARFDebugInfo::GetCompileUnitAranges() for \"%s\" from .debug_aranges",
  65                              m_dwarf2Data->GetObjectFile()->GetFileSpec().GetPath().c_str());
  66             m_cu_aranges_ap->Extract (debug_aranges_data);
  67
  68         }
  69         else
  70         {
  71             if (log)
  72                 log->Printf ("DWARFDebugInfo::GetCompileUnitAranges() for \"%s\" by parsing",
  73                              m_dwarf2Data->GetObjectFile()->GetFileSpec().GetPath().c_str());
  74             const size_t num_compile_units = GetNumCompileUnits();
  75             const bool clear_dies_if_already_not_parsed = true;
  76             for (size_t idx = 0; idx < num_compile_units; ++idx)
  77             {
  78                 DWARFCompileUnit* cu = GetCompileUnitAtIndex(idx);
  79                 if (cu)
  80                     cu->BuildAddressRangeTable (m_dwarf2Data, m_cu_aranges_ap.get(), clear_dies_if_already_not_parsed);
  81             }
  82         }
  83
  84         const bool minimize = true;
  85         m_cu_aranges_ap->Sort (minimize);
  86     }
  87     return *m_cu_aranges_ap.get();
  88 }
  89
  90
  91 //----------------------------------------------------------------------
  92 // LookupAddress
  93 //----------------------------------------------------------------------
  94 bool
  95 DWARFDebugInfo::LookupAddress
  96 (
  97     const dw_addr_t address,
  98     const dw_offset_t hint_die_offset,
  99     DWARFCompileUnitSP& cu_sp,
 100     DWARFDebugInfoEntry** function_die,
 101     DWARFDebugInfoEntry** block_die
 102 )
 103 {
 104
 105     if (hint_die_offset != DW_INVALID_OFFSET)
 106         cu_sp = GetCompileUnit(hint_die_offset);
 107     else
 108     {
 109         DWARFDebugAranges &cu_aranges = GetCompileUnitAranges ();
 110         const dw_offset_t cu_offset = cu_aranges.FindAddress (address);
 111         cu_sp = GetCompileUnit(cu_offset);
 112     }
 113
 114     if (cu_sp.get())
 115     {
 116         if (cu_sp->LookupAddress(address, function_die, block_die))
 117             return true;
 118         cu_sp.reset();
 119     }
 120     else
 121     {
 122         // The hint_die_offset may have been a pointer to the actual item that
 123         // we are looking for
 124         DWARFDebugInfoEntry* die_ptr = GetDIEPtr(hint_die_offset, &cu_sp);
 125         if (die_ptr)
 126         {
 127             if (cu_sp.get())
 128             {
 129                 if (function_die || block_die)
 130                     return die_ptr->LookupAddress(address, m_dwarf2Data, cu_sp.get(), function_die, block_die);
 131
 132                 // We only wanted the compile unit that contained this address
 133                 return true;
 134             }
 135         }
 136     }
 137     return false;
 138 }
 139
 140
 141 void
 142 DWARFDebugInfo::ParseCompileUnitHeadersIfNeeded()
 143 {
 144     if (m_compile_units.empty())
 145     {
 146         if (m_dwarf2Data != NULL)
 147         {
 148             lldb::offset_t offset = 0;
 149             const DataExtractor &debug_info_data = m_dwarf2Data->get_debug_info_data();
 150             while (debug_info_data.ValidOffset(offset))
 151             {
 152                 DWARFCompileUnitSP cu_sp(new DWARFCompileUnit(m_dwarf2Data));
 153                 // Out of memory?
 154                 if (cu_sp.get() == NULL)
 155                     break;
 156
 157                 if (cu_sp->Extract(debug_info_data, &offset) == false)
 158                     break;
 159
 160                 m_compile_units.push_back(cu_sp);
 161
 162                 offset = cu_sp->GetNextCompileUnitOffset();
 163             }
 164         }
 165     }
 166 }
 167
 168 size_t
 169 DWARFDebugInfo::GetNumCompileUnits()
 170 {
 171     ParseCompileUnitHeadersIfNeeded();
 172     return m_compile_units.size();
 173 }
 174
 175 DWARFCompileUnit*
 176 DWARFDebugInfo::GetCompileUnitAtIndex(uint32_t idx)
 177 {
 178     DWARFCompileUnit* cu = NULL;
 179     if (idx < GetNumCompileUnits())
 180         cu = m_compile_units[idx].get();
 181     return cu;
 182 }
 183
 184 bool
 185 DWARFDebugInfo::ContainsCompileUnit (const DWARFCompileUnit *cu) const
 186 {
 187     // Not a verify efficient function, but it is handy for use in assertions
 188     // to make sure that a compile unit comes from a debug information file.
 189     CompileUnitColl::const_iterator end_pos = m_compile_units.end();
 190     CompileUnitColl::const_iterator pos;
 191
 192     for (pos = m_compile_units.begin(); pos != end_pos; ++pos)
 193     {
 194         if (pos->get() == cu)
 195             return true;
 196     }
 197     return false;
 198 }
 199
 200
 201 static bool CompileUnitOffsetLessThan (const DWARFCompileUnitSP& a, const DWARFCompileUnitSP& b)
 202 {
 203     return a->GetOffset() < b->GetOffset();
 204 }
 205
 206
 207 static int
 208 CompareDWARFCompileUnitSPOffset (const void *key, const void *arrmem)
 209 {
 210     const dw_offset_t key_cu_offset = *(dw_offset_t*) key;
 211     const dw_offset_t cu_offset = ((DWARFCompileUnitSP *)arrmem)->get()->GetOffset();
 212     if (key_cu_offset < cu_offset)
 213         return -1;
 214     if (key_cu_offset > cu_offset)
 215         return 1;
 216     return 0;
 217 }
 218
 219 DWARFCompileUnitSP
 220 DWARFDebugInfo::GetCompileUnit(dw_offset_t cu_offset, uint32_t* idx_ptr)
 221 {
 222     DWARFCompileUnitSP cu_sp;
 223     uint32_t cu_idx = DW_INVALID_INDEX;
 224     if (cu_offset != DW_INVALID_OFFSET)
 225     {
 226         ParseCompileUnitHeadersIfNeeded();
 227
 228         DWARFCompileUnitSP* match = (DWARFCompileUnitSP*)bsearch(&cu_offset, &m_compile_units[0], m_compile_units.size(), sizeof(DWARFCompileUnitSP), CompareDWARFCompileUnitSPOffset);
 229         if (match)
 230         {
 231             cu_sp = *match;
 232             cu_idx = match - &m_compile_units[0];
 233         }
 234     }
 235     if (idx_ptr)
 236         *idx_ptr = cu_idx;
 237     return cu_sp;
 238 }
 239
 240 DWARFCompileUnitSP
 241 DWARFDebugInfo::GetCompileUnitContainingDIE(dw_offset_t die_offset)
 242 {
 243     DWARFCompileUnitSP cu_sp;
 244     if (die_offset != DW_INVALID_OFFSET)
 245     {
 246         ParseCompileUnitHeadersIfNeeded();
 247
 248         CompileUnitColl::const_iterator end_pos = m_compile_units.end();
 249         CompileUnitColl::const_iterator pos;
 250
 251         for (pos = m_compile_units.begin(); pos != end_pos; ++pos)
 252         {
 253             dw_offset_t cu_start_offset = (*pos)->GetOffset();
 254             dw_offset_t cu_end_offset = (*pos)->GetNextCompileUnitOffset();
 255             if (cu_start_offset <= die_offset && die_offset < cu_end_offset)
 256             {
 257                 cu_sp = *pos;
 258                 break;
 259             }
 260         }
 261     }
 262     return cu_sp;
 263 }
 264
 265 //----------------------------------------------------------------------
 266 // Compare function DWARFDebugAranges::Range structures
 267 //----------------------------------------------------------------------
 268 static bool CompareDIEOffset (const DWARFDebugInfoEntry& die1, const DWARFDebugInfoEntry& die2)
 269 {
 270     return die1.GetOffset() < die2.GetOffset();
 271 }
 272
 273
 274 //----------------------------------------------------------------------
 275 // GetDIE()
 276 //
 277 // Get the DIE (Debug Information Entry) with the specified offset.
 278 //----------------------------------------------------------------------
 279 DWARFDebugInfoEntry*
 280 DWARFDebugInfo::GetDIEPtr(dw_offset_t die_offset, DWARFCompileUnitSP* cu_sp_ptr)
 281 {
 282     DWARFCompileUnitSP cu_sp(GetCompileUnitContainingDIE(die_offset));
 283     if (cu_sp_ptr)
 284         *cu_sp_ptr = cu_sp;
 285     if (cu_sp.get())
 286         return cu_sp->GetDIEPtr(die_offset);
 287     return NULL;    // Not found in any compile units
 288 }
 289
 290 DWARFDebugInfoEntry*
 291 DWARFDebugInfo::GetDIEPtrWithCompileUnitHint (dw_offset_t die_offset, DWARFCompileUnit**cu_handle)
 292 {
 293     assert (cu_handle);
 294     DWARFDebugInfoEntry* die = NULL;
 295     if (*cu_handle)
 296         die = (*cu_handle)->GetDIEPtr(die_offset);
 297
 298     if (die == NULL)
 299     {
 300         DWARFCompileUnitSP cu_sp (GetCompileUnitContainingDIE(die_offset));
 301         if (cu_sp.get())
 302         {
 303             *cu_handle = cu_sp.get();
 304             die = cu_sp->GetDIEPtr(die_offset);
 305         }
 306     }
 307     if (die == NULL)
 308         *cu_handle = NULL;
 309     return die;
 310 }
 311
 312
 313 const DWARFDebugInfoEntry*
 314 DWARFDebugInfo::GetDIEPtrContainingOffset(dw_offset_t die_offset, DWARFCompileUnitSP* cu_sp_ptr)
 315 {
 316     DWARFCompileUnitSP cu_sp(GetCompileUnitContainingDIE(die_offset));
 317     if (cu_sp_ptr)
 318         *cu_sp_ptr = cu_sp;
 319     if (cu_sp.get())
 320         return cu_sp->GetDIEPtrContainingOffset(die_offset);
 321
 322     return NULL;    // Not found in any compile units
 323
 324 }
 325
 326 //----------------------------------------------------------------------
 327 // DWARFDebugInfo_ParseCallback
 328 //
 329 // A callback function for the static DWARFDebugInfo::Parse() function
 330 // that gets parses all compile units and DIE's into an internate
 331 // representation for further modification.
 332 //----------------------------------------------------------------------
 333
 334 static dw_offset_t
 335 DWARFDebugInfo_ParseCallback
 336 (
 337     SymbolFileDWARF* dwarf2Data,
 338     DWARFCompileUnitSP& cu_sp,
 339     DWARFDebugInfoEntry* die,
 340     const dw_offset_t next_offset,
 341     const uint32_t curr_depth,
 342     void* userData
 343 )
 344 {
 345     DWARFDebugInfo* debug_info = (DWARFDebugInfo*)userData;
 346     DWARFCompileUnit* cu = cu_sp.get();
 347     if (die)
 348     {
 349         cu->AddDIE(*die);
 350     }
 351     else if (cu)
 352     {
 353         debug_info->AddCompileUnit(cu_sp);
 354     }
 355
 356     // Just return the current offset to parse the next CU or DIE entry
 357     return next_offset;
 358 }
 359
 360 //----------------------------------------------------------------------
 361 // AddCompileUnit
 362 //----------------------------------------------------------------------
 363 void
 364 DWARFDebugInfo::AddCompileUnit(DWARFCompileUnitSP& cu)
 365 {
 366     m_compile_units.push_back(cu);
 367 }
 368
 369 /*
 370 void
 371 DWARFDebugInfo::AddDIE(DWARFDebugInfoEntry& die)
 372 {
 373     m_die_array.push_back(die);
 374 }
 375 */
 376
 377
 378
 379
 380 //----------------------------------------------------------------------
 381 // Parse
 382 //
 383 // Parses the .debug_info section and uses the .debug_abbrev section
 384 // and various other sections in the SymbolFileDWARF class and calls the
 385 // supplied callback function each time a compile unit header, or debug
 386 // information entry is successfully parsed. This function can be used
 387 // for different tasks such as parsing the file contents into a
 388 // structured data, dumping, verifying and much more.
 389 //----------------------------------------------------------------------
 390 void
 391 DWARFDebugInfo::Parse(SymbolFileDWARF* dwarf2Data, Callback callback, void* userData)
 392 {
 393     if (dwarf2Data)
 394     {
 395         lldb::offset_t offset = 0;
 396         uint32_t depth = 0;
 397         DWARFCompileUnitSP cu(new DWARFCompileUnit(dwarf2Data));
 398         if (cu.get() == NULL)
 399             return;
 400         DWARFDebugInfoEntry die;
 401
 402         while (cu->Extract(dwarf2Data->get_debug_info_data(), &offset))
 403         {
 404             const dw_offset_t next_cu_offset = cu->GetNextCompileUnitOffset();
 405
 406             depth = 0;
 407             // Call the callback function with no DIE pointer for the compile unit
 408             // and get the offset that we are to continue to parse from
 409             offset = callback(dwarf2Data, cu, NULL, offset, depth, userData);
 410
 411             // Make sure we are within our compile unit
 412             if (offset < next_cu_offset)
 413             {
 414                 // We are in our compile unit, parse starting at the offset
 415                 // we were told to parse
 416                 bool done = false;
 417                 while (!done && die.Extract(dwarf2Data, cu.get(), &offset))
 418                 {
 419                     // Call the callback function with DIE pointer that falls within the compile unit
 420                     offset = callback(dwarf2Data, cu, &die, offset, depth, userData);
 421
 422                     if (die.IsNULL())
 423                     {
 424                         if (depth)
 425                             --depth;
 426                         else
 427                             done = true;    // We are done with this compile unit!
 428                     }
 429                     else if (die.HasChildren())
 430                         ++depth;
 431                 }
 432             }
 433
 434             // Make sure the offset returned is valid, and if not stop parsing.
 435             // Returning DW_INVALID_OFFSET from this callback is a good way to end
 436             // all parsing
 437             if (!dwarf2Data->get_debug_info_data().ValidOffset(offset))
 438                 break;
 439
 440             // See if during the callback anyone retained a copy of the compile
 441             // unit other than ourselves and if so, let whomever did own the object
 442             // and create a new one for our own use!
 443             if (!cu.unique())
 444                 cu.reset(new DWARFCompileUnit(dwarf2Data));
 445
 446
 447             // Make sure we start on a proper
 448             offset = next_cu_offset;
 449         }
 450     }
 451 }
 452
 453 typedef struct DumpInfo
 454 {
 455     DumpInfo(Stream* init_strm, uint32_t off, uint32_t depth) :
 456         strm(init_strm),
 457         die_offset(off),
 458         recurse_depth(depth),
 459         found_depth(UINT32_MAX),
 460         found_die(false),
 461         ancestors()
 462     {
 463     }
 464     Stream* strm;
 465     const uint32_t die_offset;
 466     const uint32_t recurse_depth;
 467     uint32_t found_depth;
 468     bool found_die;
 469     std::vector<DWARFDebugInfoEntry> ancestors;
 470
 471     DISALLOW_COPY_AND_ASSIGN(DumpInfo);
 472 } DumpInfo;
 473
 474 //----------------------------------------------------------------------
 475 // DumpCallback
 476 //
 477 // A callback function for the static DWARFDebugInfo::Parse() function
 478 // that gets called each time a compile unit header or debug information
 479 // entry is successfully parsed.
 480 //
 481 // This function dump DWARF information and obey recurse depth and
 482 // whether a single DIE is to be dumped (or all of the data).
 483 //----------------------------------------------------------------------
 484 static dw_offset_t DumpCallback
 485 (
 486     SymbolFileDWARF* dwarf2Data,
 487     DWARFCompileUnitSP& cu_sp,
 488     DWARFDebugInfoEntry* die,
 489     const dw_offset_t next_offset,
 490     const uint32_t curr_depth,
 491     void* userData
 492 )
 493 {
 494     DumpInfo* dumpInfo = (DumpInfo*)userData;
 495
 496     const DWARFCompileUnit* cu = cu_sp.get();
 497
 498     Stream *s = dumpInfo->strm;
 499     bool show_parents = s->GetFlags().Test(DWARFDebugInfo::eDumpFlag_ShowAncestors);
 500
 501     if (die)
 502     {
 503         // Are we dumping everything?
 504         if (dumpInfo->die_offset == DW_INVALID_OFFSET)
 505         {
 506             // Yes we are dumping everything. Obey our recurse level though
 507             if (curr_depth < dumpInfo->recurse_depth)
 508                 die->Dump(dwarf2Data, cu, *s, 0);
 509         }
 510         else
 511         {
 512             // We are dumping a specific DIE entry by offset
 513             if (dumpInfo->die_offset == die->GetOffset())
 514             {
 515                 // We found the DIE we were looking for, dump it!
 516                 if (show_parents)
 517                 {
 518                     s->SetIndentLevel(0);
 519                     const uint32_t num_ancestors = dumpInfo->ancestors.size();
 520                     if (num_ancestors > 0)
 521                     {
 522                         for (uint32_t i=0; i<num_ancestors-1; ++i)
 523                         {
 524                             dumpInfo->ancestors[i].Dump(dwarf2Data, cu, *s, 0);
 525                             s->IndentMore();
 526                         }
 527                     }
 528                 }
 529
 530                 dumpInfo->found_depth = curr_depth;
 531
 532                 die->Dump(dwarf2Data, cu, *s, 0);
 533
 534                 // Note that we found the DIE we were looking for
 535                 dumpInfo->found_die = true;
 536
 537                 // Since we are dumping a single DIE, if there are no children we are done!
 538                 if (!die->HasChildren() || dumpInfo->recurse_depth == 0)
 539                     return DW_INVALID_OFFSET;   // Return an invalid address to end parsing
 540             }
 541             else if (dumpInfo->found_die)
 542             {
 543                 // Are we done with all the children?
 544                 if (curr_depth <= dumpInfo->found_depth)
 545                     return DW_INVALID_OFFSET;
 546
 547                 // We have already found our DIE and are printing it's children. Obey
 548                 // our recurse depth and return an invalid offset if we get done
 549                 // dumping all the the children
 550                 if (dumpInfo->recurse_depth == UINT32_MAX || curr_depth <= dumpInfo->found_depth + dumpInfo->recurse_depth)
 551                     die->Dump(dwarf2Data, cu, *s, 0);
 552             }
 553             else if (dumpInfo->die_offset > die->GetOffset())
 554             {
 555                 if (show_parents)
 556                     dumpInfo->ancestors.back() = *die;
 557             }
 558         }
 559
 560         // Keep up with our indent level
 561         if (die->IsNULL())
 562         {
 563             if (show_parents)
 564                 dumpInfo->ancestors.pop_back();
 565
 566             if (curr_depth <= 1)
 567                 return cu->GetNextCompileUnitOffset();
 568             else
 569                 s->IndentLess();
 570         }
 571         else if (die->HasChildren())
 572         {
 573             if (show_parents)
 574             {
 575                 DWARFDebugInfoEntry null_die;
 576                 dumpInfo->ancestors.push_back(null_die);
 577             }
 578             s->IndentMore();
 579         }
 580     }
 581     else
 582     {
 583         if (cu == NULL)
 584             s->PutCString("NULL - cu");
 585         // We have a compile unit, reset our indent level to zero just in case
 586         s->SetIndentLevel(0);
 587
 588         // See if we are dumping everything?
 589         if (dumpInfo->die_offset == DW_INVALID_OFFSET)
 590         {
 591             // We are dumping everything
 592             cu->Dump(s);
 593             return cu->GetFirstDIEOffset(); // Return true to parse all DIEs in this Compile Unit
 594         }
 595         else
 596         {
 597             if (show_parents)
 598             {
 599                 dumpInfo->ancestors.clear();
 600                 dumpInfo->ancestors.resize(1);
 601             }
 602
 603             // We are dumping only a single DIE possibly with it's children and
 604             // we must find it's compile unit before we can dump it properly
 605             if (dumpInfo->die_offset < cu->GetFirstDIEOffset())
 606             {
 607                 // Not found, maybe the DIE offset provided wasn't correct?
 608             //  *ostrm_ptr << "DIE at offset " << HEX32 << dumpInfo->die_offset << " was not found." << endl;
 609                 return DW_INVALID_OFFSET;
 610             }
 611             else
 612             {
 613                 // See if the DIE is in this compile unit?
 614                 if (dumpInfo->die_offset < cu->GetNextCompileUnitOffset())
 615                 {
 616                     // This DIE is in this compile unit!
 617                     if (s->GetVerbose())
 618                         cu->Dump(s); // Dump the compile unit for the DIE in verbose mode
 619
 620                     return next_offset;
 621                 //  // We found our compile unit that contains our DIE, just skip to dumping the requested DIE...
 622                 //  return dumpInfo->die_offset;
 623                 }
 624                 else
 625                 {
 626                     // Skip to the next compile unit as the DIE isn't in the current one!
 627                     return cu->GetNextCompileUnitOffset();
 628                 }
 629             }
 630         }
 631     }
 632
 633     // Just return the current offset to parse the next CU or DIE entry
 634     return next_offset;
 635 }
 636
 637 //----------------------------------------------------------------------
 638 // Dump
 639 //
 640 // Dump the information in the .debug_info section to the specified
 641 // ostream. If die_offset is valid, a single DIE will be dumped. If the
 642 // die_offset is invalid, all the DWARF information will be dumped. Both
 643 // cases will obey a "recurse_depth" or how deep to traverse into the
 644 // children of each DIE entry. A recurse_depth of zero will dump all
 645 // compile unit headers. A recurse_depth of 1 will dump all compile unit
 646 // headers and the DW_TAG_compile unit tags. A depth of 2 will also
 647 // dump all types and functions.
 648 //----------------------------------------------------------------------
 649 void
 650 DWARFDebugInfo::Dump
 651 (
 652     Stream *s,
 653     SymbolFileDWARF* dwarf2Data,
 654     const uint32_t die_offset,
 655     const uint32_t recurse_depth
 656 )
 657 {
 658     DumpInfo dumpInfo(s, die_offset, recurse_depth);
 659     s->PutCString(".debug_info contents");
 660     if (dwarf2Data->get_debug_info_data().GetByteSize() > 0)
 661     {
 662         if (die_offset == DW_INVALID_OFFSET)
 663             s->PutCString(":\n");
 664         else
 665         {
 666             s->Printf(" for DIE entry at .debug_info[0x%8.8x]", die_offset);
 667             if (recurse_depth != UINT32_MAX)
 668                 s->Printf(" recursing %u levels deep.", recurse_depth);
 669             s->EOL();
 670         }
 671     }
 672     else
 673     {
 674         s->PutCString(": < EMPTY >\n");
 675         return;
 676     }
 677     DWARFDebugInfo::Parse(dwarf2Data, DumpCallback, &dumpInfo);
 678 }
 679
 680
 681 //----------------------------------------------------------------------
 682 // Dump
 683 //
 684 // Dump the contents of this DWARFDebugInfo object as has been parsed
 685 // and/or modified after it has been parsed.
 686 //----------------------------------------------------------------------
 687 void
 688 DWARFDebugInfo::Dump (Stream *s, const uint32_t die_offset, const uint32_t recurse_depth)
 689 {
 690     DumpInfo dumpInfo(s, die_offset, recurse_depth);
 691
 692     s->PutCString("Dumping .debug_info section from internal representation\n");
 693
 694     CompileUnitColl::const_iterator pos;
 695     uint32_t curr_depth = 0;
 696     ParseCompileUnitHeadersIfNeeded();
 697     for (pos = m_compile_units.begin(); pos != m_compile_units.end(); ++pos)
 698     {
 699         const DWARFCompileUnitSP& cu_sp = *pos;
 700         DumpCallback(m_dwarf2Data, (DWARFCompileUnitSP&)cu_sp, NULL, 0, curr_depth, &dumpInfo);
 701
 702         const DWARFDebugInfoEntry* die = cu_sp->DIE();
 703         if (die)
 704             die->Dump(m_dwarf2Data, cu_sp.get(), *s, recurse_depth);
 705     }
 706 }
 707
 708
 709 //----------------------------------------------------------------------
 710 // FindCallbackString
 711 //
 712 // A callback function for the static DWARFDebugInfo::Parse() function
 713 // that gets called each time a compile unit header or debug information
 714 // entry is successfully parsed.
 715 //
 716 // This function will find the die_offset of any items whose DW_AT_name
 717 // matches the given string
 718 //----------------------------------------------------------------------
 719 typedef struct FindCallbackStringInfoTag
 720 {
 721     const char* name;
 722     bool ignore_case;
 723     RegularExpression* regex;
 724     vector<dw_offset_t>& die_offsets;
 725 } FindCallbackStringInfo;
 726
 727 static dw_offset_t FindCallbackString
 728 (
 729     SymbolFileDWARF* dwarf2Data,
 730     DWARFCompileUnitSP& cu_sp,
 731     DWARFDebugInfoEntry* die,
 732     const dw_offset_t next_offset,
 733     const uint32_t curr_depth,
 734     void* userData
 735 )
 736 {
 737     FindCallbackStringInfo* info = (FindCallbackStringInfo*)userData;
 738     const DWARFCompileUnit* cu = cu_sp.get();
 739
 740     if (die)
 741     {
 742         const char* die_name = die->GetName(dwarf2Data, cu);
 743         if (die_name)
 744         {
 745             if (info->regex)
 746             {
 747                 if (info->regex->Execute(die_name))
 748                     info->die_offsets.push_back(die->GetOffset());
 749             }
 750             else
 751             {
 752                 if ((info->ignore_case ? strcasecmp(die_name, info->name) : strcmp(die_name, info->name)) == 0)
 753                     info->die_offsets.push_back(die->GetOffset());
 754             }
 755         }
 756     }
 757
 758     // Just return the current offset to parse the next CU or DIE entry
 759     return next_offset;
 760 }
 761
 762 //----------------------------------------------------------------------
 763 // Find
 764 //
 765 // Finds all DIE that have a specific DW_AT_name attribute by manually
 766 // searching through the debug information (not using the
 767 // .debug_pubnames section). The string must match the entire name
 768 // and case sensitive searches are an option.
 769 //----------------------------------------------------------------------
 770 bool
 771 DWARFDebugInfo::Find(const char* name, bool ignore_case, vector<dw_offset_t>& die_offsets) const
 772 {
 773     die_offsets.clear();
 774     if (name && name[0])
 775     {
 776         FindCallbackStringInfo info = { name, ignore_case, NULL, die_offsets };
 777         DWARFDebugInfo::Parse(m_dwarf2Data, FindCallbackString, &info);
 778     }
 779     return !die_offsets.empty();
 780 }
 781
 782 //----------------------------------------------------------------------
 783 // Find
 784 //
 785 // Finds all DIE that have a specific DW_AT_name attribute by manually
 786 // searching through the debug information (not using the
 787 // .debug_pubnames section). The string must match the supplied regular
 788 // expression.
 789 //----------------------------------------------------------------------
 790 bool
 791 DWARFDebugInfo::Find(RegularExpression& re, vector<dw_offset_t>& die_offsets) const
 792 {
 793     die_offsets.clear();
 794     FindCallbackStringInfo info = { NULL, false, &re, die_offsets };
 795     DWARFDebugInfo::Parse(m_dwarf2Data, FindCallbackString, &info);
 796     return !die_offsets.empty();
 797 }