DWARFDebugRanges.cpp
4.12 KB
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
125
126
//===-- DWARFDebugRanges.cpp ----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "DWARFDebugRanges.h"
#include "DWARFUnit.h"
#include "lldb/Utility/Stream.h"
using namespace lldb_private;
static dw_addr_t GetBaseAddressMarker(uint32_t addr_size) {
switch(addr_size) {
case 2:
return 0xffff;
case 4:
return 0xffffffff;
case 8:
return 0xffffffffffffffff;
}
llvm_unreachable("GetBaseAddressMarker unsupported address size.");
}
DWARFDebugRanges::DWARFDebugRanges() : m_range_map() {}
void DWARFDebugRanges::Extract(DWARFContext &context) {
DWARFRangeList range_list;
lldb::offset_t offset = 0;
dw_offset_t debug_ranges_offset = offset;
while (Extract(context, &offset, range_list)) {
range_list.Sort();
m_range_map[debug_ranges_offset] = range_list;
debug_ranges_offset = offset;
}
}
bool DWARFDebugRanges::Extract(DWARFContext &context,
lldb::offset_t *offset_ptr,
DWARFRangeList &range_list) {
range_list.Clear();
lldb::offset_t range_offset = *offset_ptr;
const DWARFDataExtractor &debug_ranges_data = context.getOrLoadRangesData();
uint32_t addr_size = debug_ranges_data.GetAddressByteSize();
dw_addr_t base_addr = 0;
dw_addr_t base_addr_marker = GetBaseAddressMarker(addr_size);
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;
}
if (begin == base_addr_marker) {
base_addr = end;
continue;
}
// Filter out empty ranges
if (begin < end)
range_list.Append(DWARFRangeList::Entry(begin + base_addr, 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;
DumpAddress(s.AsRawOstream(), 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;
DumpAddressRange(s.AsRawOstream(), begin_addr, end_addr,
sizeof(dw_addr_t), nullptr);
}
}
}
bool DWARFDebugRanges::FindRanges(const DWARFUnit *cu,
dw_offset_t debug_ranges_offset,
DWARFRangeList &range_list) const {
dw_addr_t debug_ranges_address = cu->GetRangesBase() + 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;
// All DW_AT_ranges are relative to the base address of the compile
// unit. We add the compile unit base address to make sure all the
// addresses are properly fixed up.
range_list.Slide(cu->GetBaseAddress());
return true;
}
return false;
}