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