Home | History | Annotate | Download | only in DWARF
      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 }
    798