1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
//===-- DWARFDebugRanges.cpp ------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "DWARFDebugRanges.h"
#include "SymbolFileDWARF.h"
#include "lldb/Utility/Stream.h"
#include <assert.h>
using namespace lldb_private;
using namespace std;
DWARFDebugRanges::DWARFDebugRanges() : m_range_map() {}
DWARFDebugRanges::~DWARFDebugRanges() {}
void DWARFDebugRanges::Extract(SymbolFileDWARF *dwarf2Data) {
DWARFRangeList range_list;
lldb::offset_t offset = 0;
dw_offset_t debug_ranges_offset = offset;
while (Extract(dwarf2Data, &offset, range_list)) {
range_list.Sort();
m_range_map[debug_ranges_offset] = range_list;
debug_ranges_offset = offset;
}
}
bool DWARFDebugRanges::Extract(SymbolFileDWARF *dwarf2Data,
lldb::offset_t *offset_ptr,
DWARFRangeList &range_list) {
range_list.Clear();
lldb::offset_t range_offset = *offset_ptr;
const DWARFDataExtractor &debug_ranges_data =
dwarf2Data->get_debug_ranges_data();
uint32_t addr_size = debug_ranges_data.GetAddressByteSize();
while (
debug_ranges_data.ValidOffsetForDataOfSize(*offset_ptr, 2 * addr_size)) {
dw_addr_t begin = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
dw_addr_t end = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
if (!begin && !end) {
// End of range list
break;
}
// Extend 4 byte addresses that consists of 32 bits of 1's to be 64 bits
// of ones
switch (addr_size) {
case 2:
if (begin == 0xFFFFull)
begin = LLDB_INVALID_ADDRESS;
break;
case 4:
if (begin == 0xFFFFFFFFull)
begin = LLDB_INVALID_ADDRESS;
break;
case 8:
break;
default:
llvm_unreachable("DWARFRangeList::Extract() unsupported address size.");
}
// Filter out empty ranges
if (begin < end)
range_list.Append(DWARFRangeList::Entry(begin, end - begin));
}
// Make sure we consumed at least something
return range_offset != *offset_ptr;
}
void DWARFDebugRanges::Dump(Stream &s,
const DWARFDataExtractor &debug_ranges_data,
lldb::offset_t *offset_ptr,
dw_addr_t cu_base_addr) {
uint32_t addr_size = s.GetAddressByteSize();
dw_addr_t base_addr = cu_base_addr;
while (
debug_ranges_data.ValidOffsetForDataOfSize(*offset_ptr, 2 * addr_size)) {
dw_addr_t begin = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
dw_addr_t end = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
// Extend 4 byte addresses that consists of 32 bits of 1's to be 64 bits
// of ones
if (begin == 0xFFFFFFFFull && addr_size == 4)
begin = LLDB_INVALID_ADDRESS;
s.Indent();
if (begin == 0 && end == 0) {
s.PutCString(" End");
break;
} else if (begin == LLDB_INVALID_ADDRESS) {
// A base address selection entry
base_addr = end;
s.Address(base_addr, sizeof(dw_addr_t), " Base address = ");
} else {
// Convert from offset to an address
dw_addr_t begin_addr = begin + base_addr;
dw_addr_t end_addr = end + base_addr;
s.AddressRange(begin_addr, end_addr, sizeof(dw_addr_t), NULL);
}
}
}
bool DWARFDebugRanges::FindRanges(dw_addr_t debug_ranges_base,
dw_offset_t debug_ranges_offset,
DWARFRangeList &range_list) const {
dw_addr_t debug_ranges_address = debug_ranges_base + debug_ranges_offset;
range_map_const_iterator pos = m_range_map.find(debug_ranges_address);
if (pos != m_range_map.end()) {
range_list = pos->second;
return true;
}
return false;
}
|
