1 //===-- DWARFDebugRanges.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 "DWARFDebugRanges.h"
11 #include "SymbolFileDWARF.h"
12 #include "lldb/Core/Stream.h"
13 #include <assert.h>
14 
15 using namespace lldb_private;
16 using namespace std;
17 
18 DWARFDebugRanges::DWARFDebugRanges() :
19     m_range_map()
20 {
21 }
22 
23 DWARFDebugRanges::~DWARFDebugRanges()
24 {
25 }
26 
27 void
28 DWARFDebugRanges::Extract(SymbolFileDWARF* dwarf2Data)
29 {
30     RangeList range_list;
31     dw_offset_t offset = 0;
32     dw_offset_t debug_ranges_offset = offset;
33     while (range_list.Extract(dwarf2Data, &offset))
34     {
35         m_range_map[debug_ranges_offset] = range_list;
36         debug_ranges_offset = offset;
37     }
38 }
39 
40 bool
41 DWARFDebugRanges::RangeList::AddRange(dw_addr_t lo_addr, dw_addr_t hi_addr)
42 {
43     if (lo_addr <= hi_addr)
44     {
45         Range range(lo_addr, hi_addr);
46         ranges.push_back(range);
47         return true;
48     }
49     return false;
50 }
51 
52 const DWARFDebugRanges::Range*
53 DWARFDebugRanges::RangeList::Lookup(dw_addr_t offset) const
54 {
55     Range::const_iterator pos = ranges.begin();
56     Range::const_iterator end_pos = ranges.end();
57     for (pos = ranges.begin(); pos != end_pos; ++pos)
58     {
59         if (pos->begin_offset <= offset && offset < pos->end_offset)
60         {
61             return &(*pos);
62         }
63     }
64     return NULL;
65 }
66 
67 size_t
68 DWARFDebugRanges::RangeList::Size() const
69 {
70     return ranges.size();
71 }
72 
73 void
74 DWARFDebugRanges::RangeList::AddOffset(dw_addr_t offset)
75 {
76     if (!ranges.empty())
77     {
78         Range::iterator pos = ranges.begin();
79         Range::iterator end_pos = ranges.end();
80         for (pos = ranges.begin(); pos != end_pos; ++pos)
81         {
82             // assert for unsigned overflows
83             assert (~pos->begin_offset >= offset);
84             assert (~pos->end_offset >= offset);
85             pos->begin_offset += offset;
86             pos->end_offset += offset;
87         }
88     }
89 }
90 
91 void
92 DWARFDebugRanges::RangeList::SubtractOffset(dw_addr_t offset)
93 {
94     if (!ranges.empty())
95     {
96         Range::iterator pos = ranges.begin();
97         Range::iterator end_pos = ranges.end();
98         for (pos = ranges.begin(); pos != end_pos; ++pos)
99         {
100             assert (pos->begin_offset >= offset);
101             assert (pos->end_offset >= offset);
102             pos->begin_offset -= offset;
103             pos->end_offset -= offset;
104         }
105     }
106 }
107 
108 
109 const DWARFDebugRanges::Range*
110 DWARFDebugRanges::RangeList::RangeAtIndex(size_t i) const
111 {
112     if (i < ranges.size())
113         return &ranges[i];
114     return NULL;
115 }
116 
117 bool
118 DWARFDebugRanges::RangeList::Extract(SymbolFileDWARF* dwarf2Data, uint32_t* offset_ptr)
119 {
120     Clear();
121     uint32_t range_offset = *offset_ptr;
122     const DataExtractor& debug_ranges_data = dwarf2Data->get_debug_ranges_data();
123     uint32_t addr_size = debug_ranges_data.GetAddressByteSize();
124 
125     while (debug_ranges_data.ValidOffsetForDataOfSize(*offset_ptr, 2 * addr_size))
126     {
127         dw_addr_t begin = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
128         dw_addr_t end   = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
129         if (!begin && !end)
130         {
131             // End of range list
132             break;
133         }
134         // Extend 4 byte addresses that consits of 32 bits of 1's to be 64 bits
135         // of ones
136         switch (addr_size)
137         {
138         case 2:
139             if (begin == 0xFFFFull)
140                 begin = DW_INVALID_ADDRESS;
141             break;
142 
143         case 4:
144             if (begin == 0xFFFFFFFFull)
145                 begin = DW_INVALID_ADDRESS;
146             break;
147 
148         case 8:
149             break;
150 
151         default:
152             assert(!"DWARFDebugRanges::RangeList::Extract() unsupported address size.");
153             break;
154         }
155 
156         // Filter out empty ranges
157         if (begin != end)
158             ranges.push_back(Range(begin, end));
159     }
160 
161     // Make sure we consumed at least something
162     return range_offset != *offset_ptr;
163 }
164 
165 
166 dw_addr_t
167 DWARFDebugRanges::RangeList::LowestAddress(const dw_addr_t cu_base_addr) const
168 {
169     dw_addr_t addr = DW_INVALID_ADDRESS;
170     dw_addr_t curr_base_addr = cu_base_addr;
171     if (!ranges.empty())
172     {
173         Range::const_iterator pos = ranges.begin();
174         Range::const_iterator end_pos = ranges.end();
175         for (pos = ranges.begin(); pos != end_pos; ++pos)
176         {
177             if (pos->begin_offset == DW_INVALID_ADDRESS)
178                 curr_base_addr = pos->end_offset;
179             else if (curr_base_addr != DW_INVALID_ADDRESS)
180             {
181                 dw_addr_t curr_addr = curr_base_addr + pos->begin_offset;
182                 if (addr > curr_addr)
183                     addr = curr_addr;
184             }
185         }
186     }
187     return addr;
188 }
189 
190 dw_addr_t
191 DWARFDebugRanges::RangeList::HighestAddress(const dw_addr_t cu_base_addr) const
192 {
193     dw_addr_t addr = 0;
194     dw_addr_t curr_base_addr = cu_base_addr;
195     if (!ranges.empty())
196     {
197         Range::const_iterator pos = ranges.begin();
198         Range::const_iterator end_pos = ranges.end();
199         for (pos = ranges.begin(); pos != end_pos; ++pos)
200         {
201             if (pos->begin_offset == DW_INVALID_ADDRESS)
202                 curr_base_addr = pos->end_offset;
203             else if (curr_base_addr != DW_INVALID_ADDRESS)
204             {
205                 dw_addr_t curr_addr = curr_base_addr + pos->end_offset;
206                 if (addr < curr_addr)
207                     addr = curr_addr;
208             }
209         }
210     }
211     if (addr != 0)
212         return addr;
213     return DW_INVALID_ADDRESS;
214 }
215 
216 
217 void
218 DWARFDebugRanges::Dump(Stream *s, const DataExtractor& debug_ranges_data, uint32_t* offset_ptr, dw_addr_t cu_base_addr)
219 {
220     uint32_t addr_size = s->GetAddressByteSize();
221     bool verbose = s->GetVerbose();
222 
223     dw_addr_t base_addr = cu_base_addr;
224     while (debug_ranges_data.ValidOffsetForDataOfSize(*offset_ptr, 2 * addr_size))
225     {
226         dw_addr_t begin = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
227         dw_addr_t end   = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
228         // Extend 4 byte addresses that consits of 32 bits of 1's to be 64 bits
229         // of ones
230         if (begin == 0xFFFFFFFFull && addr_size == 4)
231             begin = DW_INVALID_ADDRESS;
232 
233         s->Indent();
234         if (verbose)
235         {
236             s->AddressRange(begin, end, sizeof (dw_addr_t), " offsets = ");
237         }
238 
239 
240         if (begin == 0 && end == 0)
241         {
242             s->PutCString(" End");
243             break;
244         }
245         else if (begin == DW_INVALID_ADDRESS)
246         {
247             // A base address selection entry
248             base_addr = end;
249             s->Address(base_addr, sizeof (dw_addr_t), " Base address = ");
250         }
251         else
252         {
253             // Convert from offset to an address
254             dw_addr_t begin_addr = begin + base_addr;
255             dw_addr_t end_addr = end + base_addr;
256 
257             s->AddressRange(begin_addr, end_addr, sizeof (dw_addr_t), verbose ? " ==> addrs = " : NULL);
258         }
259     }
260 }
261 
262 bool
263 DWARFDebugRanges::FindRanges(dw_offset_t debug_ranges_offset, RangeList& range_list) const
264 {
265     range_map_const_iterator pos = m_range_map.find(debug_ranges_offset);
266     if (pos != m_range_map.end())
267     {
268         range_list = pos->second;
269         return true;
270     }
271     return false;
272 }
273 
274 
275 
276