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 //----------------------------------------------------------------------
DWARFDebugInfo()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
SetDwarfData(SymbolFileDWARF * dwarf2Data)45 DWARFDebugInfo::SetDwarfData(SymbolFileDWARF* dwarf2Data)
46 {
47 m_dwarf2Data = dwarf2Data;
48 m_compile_units.clear();
49 }
50
51
52 DWARFDebugAranges &
GetCompileUnitAranges()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
LookupAddress(const dw_addr_t address,const dw_offset_t hint_die_offset,DWARFCompileUnitSP & cu_sp,DWARFDebugInfoEntry ** function_die,DWARFDebugInfoEntry ** block_die)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
ParseCompileUnitHeadersIfNeeded()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
GetNumCompileUnits()186 DWARFDebugInfo::GetNumCompileUnits()
187 {
188 ParseCompileUnitHeadersIfNeeded();
189 return m_compile_units.size();
190 }
191
192 DWARFCompileUnit*
GetCompileUnitAtIndex(uint32_t idx)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
ContainsCompileUnit(const DWARFCompileUnit * cu) const202 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
CompileUnitOffsetLessThan(const DWARFCompileUnitSP & a,const DWARFCompileUnitSP & b)218 static bool CompileUnitOffsetLessThan (const DWARFCompileUnitSP& a, const DWARFCompileUnitSP& b)
219 {
220 return a->GetOffset() < b->GetOffset();
221 }
222
223
224 static int
CompareDWARFCompileUnitSPOffset(const void * key,const void * arrmem)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
GetCompileUnit(dw_offset_t cu_offset,uint32_t * idx_ptr)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
GetCompileUnitContainingDIE(dw_offset_t die_offset)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 //----------------------------------------------------------------------
CompareDIEOffset(const DWARFDebugInfoEntry & die1,const DWARFDebugInfoEntry & die2)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*
GetDIEPtr(dw_offset_t die_offset,DWARFCompileUnitSP * cu_sp_ptr)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*
GetDIEPtrWithCompileUnitHint(dw_offset_t die_offset,DWARFCompileUnit ** cu_handle)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*
GetDIEPtrContainingOffset(dw_offset_t die_offset,DWARFCompileUnitSP * cu_sp_ptr)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
DWARFDebugInfo_ParseCallback(SymbolFileDWARF * dwarf2Data,DWARFCompileUnitSP & cu_sp,DWARFDebugInfoEntry * die,const dw_offset_t next_offset,const uint32_t curr_depth,void * userData)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
AddCompileUnit(DWARFCompileUnitSP & cu)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
Parse(SymbolFileDWARF * dwarf2Data,Callback callback,void * userData)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 {
DumpInfoDumpInfo472 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 //----------------------------------------------------------------------
DumpCallback(SymbolFileDWARF * dwarf2Data,DWARFCompileUnitSP & cu_sp,DWARFDebugInfoEntry * die,const dw_offset_t next_offset,const uint32_t curr_depth,void * userData)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
Dump(Stream * s,SymbolFileDWARF * dwarf2Data,const uint32_t die_offset,const uint32_t recurse_depth)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
Dump(Stream * s,const uint32_t die_offset,const uint32_t recurse_depth)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
FindCallbackString(SymbolFileDWARF * dwarf2Data,DWARFCompileUnitSP & cu_sp,DWARFDebugInfoEntry * die,const dw_offset_t next_offset,const uint32_t curr_depth,void * userData)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
Find(const char * name,bool ignore_case,vector<dw_offset_t> & die_offsets) const788 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
Find(RegularExpression & re,vector<dw_offset_t> & die_offsets) const808 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 }
815