1 /*
2 Copyright (c) 2020, David Anderson
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with
6 or without modification, are permitted provided that the
7 following conditions are met:
8
9 Redistributions of source code must retain the above
10 copyright notice, this list of conditions and the following
11 disclaimer.
12
13 Redistributions in binary form must reproduce the above
14 copyright notice, this list of conditions and the following
15 disclaimer in the documentation and/or other materials
16 provided with the distribution.
17
18 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include "config.h"
34 #include <stdio.h>
35 #include <stdlib.h>
36 #ifdef HAVE_STDLIB_H
37 #include <stdlib.h>
38 #endif /* HAVE_STDLIB_H */
39 #include "dwarf_incl.h"
40 #include "dwarf_alloc.h"
41 #include "dwarf_error.h"
42 #include "dwarf_util.h"
43 #include "dwarfstring.h"
44 #include "dwarf_rnglists.h"
45
46 #define SIZEOFT8 1
47 #define SIZEOFT16 2
48 #define SIZEOFT32 4
49 #define SIZEOFT64 8
50 #define TRUE 1
51 #define FALSE 0
52
53
54 /* Used in case of error reading the
55 rnglists headers (not referring to Dwarf_Rnglists_Head
56 here), to clean up. */
57 static void
free_rnglists_chain(Dwarf_Debug dbg,Dwarf_Chain head)58 free_rnglists_chain(Dwarf_Debug dbg, Dwarf_Chain head)
59 {
60 Dwarf_Chain cur = head;
61 Dwarf_Chain next = 0;
62
63 if(!head) {
64 return;
65 }
66 for( ;cur; cur = next) {
67 next = cur->ch_next;
68 if (cur->ch_item) {
69 free(cur->ch_item);
70 cur->ch_item = 0;
71 dwarf_dealloc(dbg,cur,DW_DLA_CHAIN);
72 }
73 }
74 }
75
76 static int
read_single_rle_entry(Dwarf_Debug dbg,Dwarf_Small * data,Dwarf_Unsigned dataoffset,Dwarf_Small * enddata,unsigned address_size,unsigned * bytes_count_out,unsigned * entry_kind,Dwarf_Unsigned * entry_operand1,Dwarf_Unsigned * entry_operand2,Dwarf_Error * err)77 read_single_rle_entry(Dwarf_Debug dbg,
78 Dwarf_Small *data,
79 Dwarf_Unsigned dataoffset,
80 Dwarf_Small *enddata,
81 unsigned address_size,
82 unsigned *bytes_count_out,
83 unsigned *entry_kind,
84 Dwarf_Unsigned *entry_operand1,
85 Dwarf_Unsigned *entry_operand2,
86 Dwarf_Error* err)
87 {
88 Dwarf_Unsigned count = 0;
89 unsigned leblen = 0;
90 unsigned code = 0;
91 Dwarf_Unsigned val1 = 0;
92 Dwarf_Unsigned val2 = 0;
93
94 code = *data;
95 ++data;
96 ++count;
97 switch(code) {
98 case DW_RLE_end_of_list: break;
99 case DW_RLE_base_addressx:{
100 DECODE_LEB128_UWORD_LEN_CK(data,val1,leblen,
101 dbg,err,enddata);
102 count += leblen;
103 }
104 break;
105 case DW_RLE_startx_endx:
106 case DW_RLE_startx_length:
107 case DW_RLE_offset_pair: {
108 DECODE_LEB128_UWORD_LEN_CK(data,val1,leblen,
109 dbg,err,enddata);
110 count += leblen;
111 DECODE_LEB128_UWORD_LEN_CK(data,val2,leblen,
112 dbg,err,enddata);
113 count += leblen;
114 }
115 break;
116 case DW_RLE_base_address: {
117 READ_UNALIGNED_CK(dbg,val1, Dwarf_Unsigned,
118 data,address_size,err,enddata);
119 data += address_size;
120 count += address_size;
121 }
122 break;
123 case DW_RLE_start_end: {
124 READ_UNALIGNED_CK(dbg,val1, Dwarf_Unsigned,
125 data,address_size,err,enddata);
126 data += address_size;
127 count += address_size;
128 READ_UNALIGNED_CK(dbg,val2, Dwarf_Unsigned,
129 data,address_size,err,enddata);
130 data += address_size;
131 count += address_size;
132 }
133 break;
134 case DW_RLE_start_length: {
135 READ_UNALIGNED_CK(dbg,val1, Dwarf_Unsigned,
136 data,address_size,err,enddata);
137 data += address_size;
138 count += address_size;
139 DECODE_LEB128_UWORD_LEN_CK(data,val2,leblen,
140 dbg,err,enddata);
141 count += leblen;
142 }
143 break;
144 default: {
145 dwarfstring m;
146
147 dwarfstring_constructor(&m);
148 dwarfstring_append_printf_u(&m,
149 "DW_DLE_RNGLISTS_ERROR: "
150 "The rangelists entry at .debug_rnglists"
151 " offset 0x%x" ,dataoffset);
152 dwarfstring_append_printf_u(&m,
153 " has code 0x%x which is unknown",code);
154 _dwarf_error_string(dbg,err,DW_DLE_RNGLISTS_ERROR,
155 dwarfstring_string(&m));
156 dwarfstring_destructor(&m);
157 return DW_DLV_ERROR;
158 }
159 break;
160 }
161 *bytes_count_out = count;
162 *entry_kind = code;
163 *entry_operand1 = val1;
164 *entry_operand2 = val2;
165 return DW_DLV_OK;
166 }
167
168 /* Reads the header. Determines the
169 various offsets, including offset
170 of the next header. Does no memory
171 allocations here. */
172 static int
internal_read_header(Dwarf_Debug dbg,Dwarf_Unsigned contextnum,Dwarf_Unsigned sectionlength,Dwarf_Small * data,Dwarf_Small * end_data,Dwarf_Unsigned offset,Dwarf_Rnglists_Context buildhere,Dwarf_Unsigned * next_offset,Dwarf_Error * error)173 internal_read_header(Dwarf_Debug dbg,
174 Dwarf_Unsigned contextnum,
175 Dwarf_Unsigned sectionlength,
176 Dwarf_Small *data,
177 Dwarf_Small *end_data,
178 Dwarf_Unsigned offset,
179 Dwarf_Rnglists_Context buildhere,
180 Dwarf_Unsigned *next_offset,
181 Dwarf_Error *error)
182 {
183 Dwarf_Small *startdata = data;
184 Dwarf_Unsigned arealen = 0;
185 int length_size = 0;
186 int exten_size = 0;
187 Dwarf_Unsigned version = 0;
188 unsigned address_size = 0;
189 unsigned segment_selector_size= 0;
190 Dwarf_Unsigned offset_entry_count = 0;
191 Dwarf_Unsigned localoff = 0;
192 Dwarf_Unsigned lists_len = 0;
193
194 READ_AREA_LENGTH_CK(dbg,arealen,Dwarf_Unsigned,
195 data,length_size,exten_size,
196 error,
197 sectionlength,end_data);
198 if (arealen > sectionlength) {
199 dwarfstring m;
200 dwarfstring_constructor(&m);
201 dwarfstring_append_printf_u(&m,
202 "DW_DLE_SECTION_SIZE_ERROR: A .debug_rnglists "
203 "area size of 0x%x ",arealen);
204 dwarfstring_append_printf_u(&m,
205 "at offset 0x%x ",offset);
206 dwarfstring_append_printf_u(&m,
207 "is larger than the entire section size of "
208 "0x%x. Corrupt DWARF.",sectionlength);
209 _dwarf_error_string(dbg,error,DW_DLE_SECTION_SIZE_ERROR,
210 dwarfstring_string(&m));
211 dwarfstring_destructor(&m);
212 return DW_DLV_ERROR;
213 }
214
215 buildhere->rc_length = arealen +length_size+exten_size;
216 buildhere->rc_dbg = dbg;
217 buildhere->rc_index = contextnum;
218 buildhere->rc_header_offset = offset;
219 buildhere->rc_offset_size = length_size;
220 buildhere->rc_extension_size = exten_size;
221 READ_UNALIGNED_CK(dbg,version,Dwarf_Unsigned,data,
222 SIZEOFT16,error,end_data);
223 if (version != DW_CU_VERSION5) {
224 dwarfstring m;
225 dwarfstring_constructor(&m);
226 dwarfstring_append_printf_u(&m,
227 "DW_DLE_VERSION_STAMP_ERROR: The version should be 5 "
228 "but we find %u instead.",version);
229 _dwarf_error_string(dbg,error,DW_DLE_VERSION_STAMP_ERROR,
230 dwarfstring_string(&m));
231 dwarfstring_destructor(&m);
232 return DW_DLV_ERROR;
233 }
234 buildhere->rc_version = version;
235 data += SIZEOFT16;
236
237 READ_UNALIGNED_CK(dbg,address_size,unsigned,data,
238 SIZEOFT8,error,end_data);
239 if (version != DW_CU_VERSION5) {
240 dwarfstring m;
241 dwarfstring_constructor(&m);
242 dwarfstring_append_printf_u(&m,
243 "DW_DLE_VERSION_STAMP_ERROR: The version should be 5 "
244 "but we find %u instead.",version);
245 _dwarf_error_string(dbg,error,DW_DLE_VERSION_STAMP_ERROR,
246 dwarfstring_string(&m));
247 dwarfstring_destructor(&m);
248 return DW_DLV_ERROR;
249 }
250 if (address_size != 4 && address_size != 8 &&
251 address_size != 2) {
252 dwarfstring m;
253 dwarfstring_constructor(&m);
254 dwarfstring_append_printf_u(&m,
255 " DW_DLE_ADDRESS_SIZE_ERROR: The address size "
256 "of %u is not supported.",address_size);
257 _dwarf_error_string(dbg,error,DW_DLE_ADDRESS_SIZE_ERROR,
258 dwarfstring_string(&m));
259 dwarfstring_destructor(&m);
260 return DW_DLV_ERROR;
261 }
262 buildhere->rc_address_size = address_size;
263 data++;
264
265 READ_UNALIGNED_CK(dbg,segment_selector_size,unsigned,data,
266 SIZEOFT8,error,end_data);
267 buildhere->rc_segment_selector_size = segment_selector_size;
268 data++;
269
270 READ_UNALIGNED_CK(dbg,offset_entry_count,Dwarf_Unsigned,data,
271 SIZEOFT32,error,end_data);
272 buildhere->rc_offset_entry_count = offset_entry_count;
273 data += SIZEOFT32;
274 if (offset_entry_count ){
275 buildhere->rc_offsets_array = data;
276 }
277 localoff = data - startdata;
278 lists_len = address_size *offset_entry_count;
279
280 data += lists_len;
281
282 buildhere->rc_offsets_off_in_sect = offset+localoff;
283 buildhere->rc_first_rnglist_offset = offset+localoff+
284 lists_len;
285 buildhere->rc_rnglists_header = startdata;
286 buildhere->rc_endaddr = startdata +buildhere->rc_length;
287 buildhere->rc_past_last_rnglist_offset =
288 buildhere->rc_header_offset +buildhere->rc_length;
289 *next_offset = buildhere->rc_past_last_rnglist_offset;
290 return DW_DLV_OK;
291 }
292
293
294 /* We return a pointer to an array of contexts
295 (not context pointers through *cxt if
296 we succeed and are returning DW_DLV_OK.
297 We never return DW_DLV_NO_ENTRY here. */
298 static int
internal_load_rnglists_contexts(Dwarf_Debug dbg,Dwarf_Rnglists_Context ** cxt,Dwarf_Unsigned * count,Dwarf_Error * error)299 internal_load_rnglists_contexts(Dwarf_Debug dbg,
300 Dwarf_Rnglists_Context **cxt,
301 Dwarf_Unsigned *count,
302 Dwarf_Error *error)
303 {
304 Dwarf_Unsigned offset = 0;
305 Dwarf_Unsigned nextoffset = 0;
306 Dwarf_Small * data = dbg->de_debug_rnglists.dss_data;
307 Dwarf_Unsigned section_size = dbg->de_debug_rnglists.dss_size;
308 Dwarf_Small * startdata = data;
309 Dwarf_Small * end_data = data +section_size;
310 Dwarf_Chain curr_chain = 0;
311 Dwarf_Chain prev_chain = 0;
312 Dwarf_Chain head_chain = 0;
313 int res = 0;
314 Dwarf_Unsigned chainlength = 0;
315 Dwarf_Rnglists_Context *fullarray = 0;
316 Dwarf_Unsigned i = 0;
317
318 for( ; data < end_data ; ) {
319 Dwarf_Rnglists_Context newcontext = 0;
320
321 /* sizeof the context struct, not sizeof a pointer */
322 newcontext = malloc(sizeof(*newcontext));
323 if (!newcontext) {
324 free_rnglists_chain(dbg,head_chain);
325 _dwarf_error_string(dbg,error,
326 DW_DLE_ALLOC_FAIL,
327 "DW_DLE_ALLOC_FAIL: Allocation of "
328 "Rnglists_Context failed");
329 return DW_DLV_ERROR;
330 }
331 memset(newcontext,0,sizeof(*newcontext));
332 res = internal_read_header(dbg,chainlength,
333 section_size,
334 data,end_data,offset,
335 newcontext,&nextoffset,error);
336 if (res == DW_DLV_ERROR) {
337 free(newcontext);
338 free_rnglists_chain(dbg,head_chain);
339 }
340 curr_chain = (Dwarf_Chain)
341 _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
342 if (curr_chain == NULL) {
343 free_rnglists_chain(dbg,head_chain);
344 _dwarf_error_string(dbg, error, DW_DLE_ALLOC_FAIL,
345 "DW_DLE_ALLOC_FAIL: allocating Rnglists_Context"
346 " chain entry");
347 return DW_DLV_ERROR;
348 }
349 curr_chain->ch_item = newcontext;
350 ++chainlength;
351 if (head_chain == NULL) {
352 head_chain = prev_chain = curr_chain;
353 } else {
354 prev_chain->ch_next = curr_chain;
355 prev_chain = curr_chain;
356 }
357 data = startdata+nextoffset;
358 offset = nextoffset;
359 }
360 fullarray= (Dwarf_Rnglists_Context *)malloc(
361 chainlength *sizeof(Dwarf_Rnglists_Context /*pointer*/));
362 if (!fullarray) {
363 free_rnglists_chain(dbg,head_chain);
364 _dwarf_error_string(dbg,error,
365 DW_DLE_ALLOC_FAIL,"Allocation of "
366 "Rnglists_Context pointer array failed");
367 return DW_DLV_ERROR;
368 }
369 curr_chain = head_chain;
370 for( i = 0; i < chainlength; ++i) {
371 fullarray[i] = (Dwarf_Rnglists_Context)curr_chain->ch_item;
372 curr_chain->ch_item = 0;
373 prev_chain = curr_chain;
374 curr_chain = curr_chain->ch_next;
375 dwarf_dealloc(dbg, prev_chain, DW_DLA_CHAIN);
376 }
377 /* ASSERT: the chain is entirely dealloc'd
378 and the array of pointers points to
379 individually malloc'd Dwarf_Rnglists_Context_s */
380 *cxt = fullarray;
381 *count = chainlength;
382 return DW_DLV_OK;
383 }
384
385
386
387 /* Used by dwarfdump to print raw rnglists data.
388 Loads all the .debug_rnglists[.dwo] headers and
389 returns DW_DLV_NO_ENTRY if the section
390 is missing or empty.
391 Intended to be done quite early and
392 done exactly once.
393 Harmless to do more than once.
394 With DW_DLV_OK it returns the number of
395 rnglists headers in the section through
396 rnglists_count. */
dwarf_load_rnglists(Dwarf_Debug dbg,Dwarf_Unsigned * rnglists_count,UNUSEDARG Dwarf_Error * error)397 int dwarf_load_rnglists(
398 Dwarf_Debug dbg,
399 Dwarf_Unsigned *rnglists_count,
400 UNUSEDARG Dwarf_Error *error)
401 {
402 int res = DW_DLV_ERROR;
403 Dwarf_Rnglists_Context *cxt = 0;
404 Dwarf_Unsigned count = 0;
405
406 if (dbg->de_rnglists_context) {
407 if (rnglists_count) {
408 *rnglists_count = dbg->de_rnglists_context_count;
409 }
410 }
411 if (!dbg->de_debug_rnglists.dss_size) {
412 /* nothing there. */
413 return DW_DLV_NO_ENTRY;
414 }
415 if (!dbg->de_debug_rnglists.dss_data) {
416 res = _dwarf_load_section(dbg, &dbg->de_debug_rnglists,
417 error);
418 if (res != DW_DLV_OK) {
419 return res;
420 }
421 }
422 res = internal_load_rnglists_contexts(dbg,&cxt,&count,error);
423 if (res == DW_DLV_ERROR) {
424 return res;
425 }
426 dbg->de_rnglists_context = cxt;
427 dbg->de_rnglists_context_count = count;
428 if (rnglists_count) {
429 *rnglists_count = count;
430 }
431 return DW_DLV_OK;
432 }
433
434 /* Frees the memory in use in all rnglists contexts.
435 Done by dwarf_finish() */
436 void
_dwarf_dealloc_rnglists_context(Dwarf_Debug dbg)437 _dwarf_dealloc_rnglists_context(Dwarf_Debug dbg)
438 {
439 Dwarf_Unsigned i = 0;
440 Dwarf_Rnglists_Context * rngcon = 0;
441
442 if (!dbg->de_rnglists_context) {
443 return;
444 }
445 rngcon = dbg->de_rnglists_context;
446 for( ; i < dbg->de_rnglists_context_count; ++i,++rngcon) {
447 Dwarf_Rnglists_Context con = *rngcon;
448 con->rc_offsets_array = 0;
449 con->rc_offset_entry_count = 0;
450 free(con);
451 }
452 free(dbg->de_rnglists_context);
453 dbg->de_rnglists_context = 0;
454 dbg->de_rnglists_context_count = 0;
455 }
456
457 /* Used by dwarfdump to print raw rnglists data. */
458 int
dwarf_get_rnglist_offset_index_value(Dwarf_Debug dbg,Dwarf_Unsigned context_index,Dwarf_Unsigned offsetentry_index,Dwarf_Unsigned * offset_value_out,Dwarf_Unsigned * global_offset_value_out,Dwarf_Error * error)459 dwarf_get_rnglist_offset_index_value(
460 Dwarf_Debug dbg,
461 Dwarf_Unsigned context_index,
462 Dwarf_Unsigned offsetentry_index,
463 Dwarf_Unsigned * offset_value_out,
464 Dwarf_Unsigned * global_offset_value_out,
465 Dwarf_Error *error)
466 {
467 Dwarf_Rnglists_Context con = 0;
468 unsigned offset_len = 0;
469 Dwarf_Small *offsetptr = 0;
470 Dwarf_Unsigned targetoffset = 0;
471
472 if (!dbg->de_rnglists_context_count) {
473 return DW_DLV_NO_ENTRY;
474 }
475 if (context_index >= dbg->de_rnglists_context_count) {
476 return DW_DLV_NO_ENTRY;
477 }
478 con = dbg->de_rnglists_context[context_index];
479
480 if (offsetentry_index >= con->rc_offset_entry_count) {
481 return DW_DLV_NO_ENTRY;
482 }
483 offset_len = con->rc_offset_size;
484 offsetptr = con->rc_offsets_array +
485 (offsetentry_index*offset_len);
486 READ_UNALIGNED_CK(dbg,targetoffset,Dwarf_Unsigned,
487 offsetptr,
488 offset_len,error,con->rc_endaddr);
489 if (offset_value_out) {
490 *offset_value_out = targetoffset;
491 }
492 if (global_offset_value_out) {
493 *global_offset_value_out = targetoffset +
494 con->rc_offsets_off_in_sect;
495 }
496 return DW_DLV_OK;
497 }
498
499 /* Used by dwarfdump to print basic data from the
500 data generated to look at a specific rangelist
501 as returned by dwarf_rnglists_index_get_rle_head()
502 or dwarf_rnglists_offset_get_rle_head. */
dwarf_get_rnglist_head_basics(Dwarf_Rnglists_Head head,Dwarf_Unsigned * rle_count,Dwarf_Unsigned * rle_version,Dwarf_Unsigned * rnglists_index_returned,Dwarf_Unsigned * bytes_total_in_rle,Dwarf_Half * offset_size,Dwarf_Half * address_size,Dwarf_Half * segment_selector_size,Dwarf_Unsigned * overall_offset_of_this_context,Dwarf_Unsigned * total_length_of_this_context,Dwarf_Unsigned * offset_table_offset,Dwarf_Unsigned * offset_table_entrycount,Dwarf_Bool * rnglists_base_present,Dwarf_Unsigned * rnglists_base,Dwarf_Bool * rnglists_base_address_present,Dwarf_Unsigned * rnglists_base_address,Dwarf_Bool * rnglists_debug_addr_base_present,Dwarf_Unsigned * rnglists_debug_addr_base,UNUSEDARG Dwarf_Error * error)503 int dwarf_get_rnglist_head_basics(
504 Dwarf_Rnglists_Head head,
505 Dwarf_Unsigned * rle_count,
506 Dwarf_Unsigned * rle_version,
507 Dwarf_Unsigned * rnglists_index_returned,
508 Dwarf_Unsigned * bytes_total_in_rle,
509 Dwarf_Half * offset_size,
510 Dwarf_Half * address_size,
511 Dwarf_Half * segment_selector_size,
512 Dwarf_Unsigned * overall_offset_of_this_context,
513 Dwarf_Unsigned * total_length_of_this_context,
514 Dwarf_Unsigned * offset_table_offset,
515 Dwarf_Unsigned * offset_table_entrycount,
516 Dwarf_Bool * rnglists_base_present,
517 Dwarf_Unsigned * rnglists_base,
518 Dwarf_Bool * rnglists_base_address_present,
519 Dwarf_Unsigned * rnglists_base_address,
520 Dwarf_Bool * rnglists_debug_addr_base_present,
521 Dwarf_Unsigned * rnglists_debug_addr_base,
522 UNUSEDARG Dwarf_Error *error)
523 {
524 Dwarf_Rnglists_Context rngcontext = 0;
525 *rle_count = head->rh_count;
526 *rle_version = head->rh_version;
527 *rnglists_index_returned = head->rh_index;
528 *bytes_total_in_rle = head->rh_bytes_total;
529 *offset_size = head->rh_offset_size;
530 *address_size = head->rh_address_size;
531 *segment_selector_size = head->rh_segment_selector_size;
532 rngcontext = head->rh_localcontext;
533 if (rngcontext) {
534 *overall_offset_of_this_context = rngcontext->rc_header_offset;
535 *total_length_of_this_context = rngcontext->rc_length;
536 *offset_table_offset = rngcontext->rc_offsets_off_in_sect;
537 *offset_table_entrycount = rngcontext->rc_offset_entry_count;
538 }
539 *rnglists_base_present = head->rh_at_rnglists_base_present;
540 *rnglists_base= head->rh_at_rnglists_base;
541
542 *rnglists_base_address_present = head->rh_cu_base_address_present;
543 *rnglists_base_address= head->rh_cu_base_address;
544
545 *rnglists_debug_addr_base_present = head->rh_cu_addr_base_present;
546 *rnglists_debug_addr_base = head->rh_cu_addr_base;
547 return DW_DLV_OK;
548 }
549
550 /* Used by dwarfdump to print raw rnglists data.
551 Enables printing of details about the Range List Table
552 Headers, one header per call. Index starting at 0.
553 Returns DW_DLV_NO_ENTRY if index is too high for the table.
554 A .debug_rnglists section may contain any number
555 of Range List Table Headers with their details. */
dwarf_get_rnglist_context_basics(Dwarf_Debug dbg,Dwarf_Unsigned context_index,Dwarf_Unsigned * header_offset,Dwarf_Small * offset_size,Dwarf_Small * extension_size,unsigned * version,Dwarf_Small * address_size,Dwarf_Small * segment_selector_size,Dwarf_Unsigned * offset_entry_count,Dwarf_Unsigned * offset_of_offset_array,Dwarf_Unsigned * offset_of_first_rangeentry,Dwarf_Unsigned * offset_past_last_rangeentry,UNUSEDARG Dwarf_Error * error)556 int dwarf_get_rnglist_context_basics(
557 Dwarf_Debug dbg,
558 Dwarf_Unsigned context_index,
559 Dwarf_Unsigned * header_offset,
560 Dwarf_Small * offset_size,
561 Dwarf_Small * extension_size,
562 unsigned * version, /* 5 */
563 Dwarf_Small * address_size,
564 Dwarf_Small * segment_selector_size,
565 Dwarf_Unsigned * offset_entry_count,
566 Dwarf_Unsigned * offset_of_offset_array,
567 Dwarf_Unsigned * offset_of_first_rangeentry,
568 Dwarf_Unsigned * offset_past_last_rangeentry,
569 UNUSEDARG Dwarf_Error *error)
570 {
571 Dwarf_Rnglists_Context con = 0;
572 if (!dbg->de_rnglists_context_count) {
573 return DW_DLV_NO_ENTRY;
574 }
575 if (context_index >= dbg->de_rnglists_context_count) {
576 return DW_DLV_NO_ENTRY;
577 }
578 con = dbg->de_rnglists_context[context_index];
579
580 if (header_offset) {
581 *header_offset = con->rc_header_offset;
582 }
583 if (offset_size) {
584 *offset_size = con->rc_offset_size;
585 }
586 if (offset_size) {
587 *extension_size = con->rc_extension_size;
588 }
589 if (version) {
590 *version = con->rc_version;
591 }
592 if (address_size) {
593 *address_size = con->rc_address_size;
594 }
595 if (segment_selector_size) {
596 *segment_selector_size = con->rc_segment_selector_size;
597 }
598 if (offset_entry_count) {
599 *offset_entry_count = con->rc_offset_entry_count;
600 }
601 if (offset_of_offset_array) {
602 *offset_of_offset_array = con->rc_offsets_off_in_sect;
603 }
604 if (offset_of_first_rangeentry) {
605 *offset_of_first_rangeentry = con->rc_first_rnglist_offset;
606 }
607 if (offset_past_last_rangeentry) {
608 *offset_past_last_rangeentry =
609 con->rc_past_last_rnglist_offset;
610 }
611 return DW_DLV_OK;
612 }
613
614 /* Used by dwarfdump to print raw rnglists data.
615 entry offset is offset_of_first_rangeentry.
616 Stop when the returned *next_entry_offset
617 is == offset_past_last_rangentry (from
618 dwarf_get_rnglist_context_plus).
619 This only makes sense within those ranges.
620 This retrieves raw detail from the section,
621 no base values or anything are added.
622 So this returns raw individual entries
623 for a single rnglist header, meaning a
624 a single Dwarf_Rnglists_Context. */
dwarf_get_rnglist_rle(Dwarf_Debug dbg,Dwarf_Unsigned contextnumber,Dwarf_Unsigned entry_offset,Dwarf_Unsigned endoffset,unsigned * entrylen,unsigned * entry_kind,Dwarf_Unsigned * entry_operand1,Dwarf_Unsigned * entry_operand2,Dwarf_Error * err)625 int dwarf_get_rnglist_rle(
626 Dwarf_Debug dbg,
627 Dwarf_Unsigned contextnumber,
628 Dwarf_Unsigned entry_offset,
629 Dwarf_Unsigned endoffset,
630 unsigned *entrylen,
631 unsigned *entry_kind,
632 Dwarf_Unsigned *entry_operand1,
633 Dwarf_Unsigned *entry_operand2,
634 Dwarf_Error *err)
635 {
636 Dwarf_Rnglists_Context con = 0;
637 Dwarf_Small *data = 0;
638 Dwarf_Small *enddata = 0;
639 int res = 0;
640 unsigned address_size = 0;
641
642 if (!dbg->de_rnglists_context_count) {
643 return DW_DLV_NO_ENTRY;
644 }
645 data = dbg->de_debug_rnglists.dss_data +
646 entry_offset;
647 enddata = dbg->de_debug_rnglists.dss_data +
648 endoffset;
649 if (contextnumber >= dbg->de_rnglists_context_count) {
650 return DW_DLV_NO_ENTRY;
651 }
652
653 con = dbg->de_rnglists_context[contextnumber];
654 address_size = con->rc_address_size;
655
656 res = read_single_rle_entry(dbg,
657 data,entry_offset,enddata,
658 address_size,entrylen,
659 entry_kind, entry_operand1, entry_operand2,
660 err);
661 return res;
662 }
663
664
665 static int
_dwarf_which_rnglists_context(Dwarf_Debug dbg,Dwarf_CU_Context ctx,Dwarf_Unsigned rnglist_offset,Dwarf_Unsigned * index,Dwarf_Error * error)666 _dwarf_which_rnglists_context(Dwarf_Debug dbg,
667 Dwarf_CU_Context ctx,
668 Dwarf_Unsigned rnglist_offset,
669 Dwarf_Unsigned *index,
670 Dwarf_Error *error)
671 {
672 Dwarf_Unsigned count;
673 Dwarf_Rnglists_Context *array;
674 Dwarf_Unsigned i = 0;
675
676 array = dbg->de_rnglists_context;
677 count = dbg->de_rnglists_context_count;
678 /* Using the slow way, a simple linear search. */
679 if (!ctx->cc_rnglists_base_present) {
680 /* We look at the location of each rnglist context
681 to find one with the offset the DIE gave us. */
682 for ( i = 0 ; i < count; ++i) {
683 Dwarf_Rnglists_Context rcx = array[i];
684 Dwarf_Unsigned rcxoff = rcx->rc_header_offset;
685 Dwarf_Unsigned rcxend = rcxoff +
686 rcx->rc_length;
687
688 if (rnglist_offset < rcxoff){
689 continue;
690 }
691 if (rnglist_offset < rcxend ){
692 *index = i;
693 return DW_DLV_OK;
694 }
695 }
696 {
697 dwarfstring m;
698
699 dwarfstring_constructor(&m);
700 dwarfstring_append_printf_u(&m,
701 "DW_DLE_RNGLISTS_ERROR: rnglist ran off end "
702 " finding target offset of"
703 " 0x%" DW_PR_XZEROS DW_PR_DUx ,rnglist_offset);
704 dwarfstring_append(&m,
705 " Not found anywhere in .debug_rnglists "
706 "data. Corrupted data?");
707 _dwarf_error_string(dbg,error,
708 DW_DLE_RNGLISTS_ERROR,
709 dwarfstring_string(&m));
710 dwarfstring_destructor(&m);
711 return DW_DLV_ERROR;
712 }
713 } else {
714 /* We have a DW_AT_rnglists_base (cc_rangelists_base),
715 let's use it. */
716 Dwarf_Unsigned lookfor = 0;;
717
718 lookfor = ctx->cc_rnglists_base;
719 for ( i = 0 ; i < count; ++i) {
720 dwarfstring m;
721
722 Dwarf_Rnglists_Context rcx = array[i];
723 if (rcx->rc_offsets_off_in_sect == lookfor){
724 *index = i;
725 return DW_DLV_OK;
726 }
727 if (rcx->rc_offsets_off_in_sect < lookfor){
728 continue;
729 }
730
731 dwarfstring_constructor(&m);
732 dwarfstring_append_printf_u(&m,
733 "DW_DLE_RNGLISTS_ERROR: rnglists base of "
734 " 0x%" DW_PR_XZEROS DW_PR_DUx ,lookfor);
735 dwarfstring_append_printf_u(&m,
736 " was not found though we are now at base "
737 " 0x%" DW_PR_XZEROS DW_PR_DUx ,
738 rcx->rc_offsets_off_in_sect);
739 _dwarf_error_string(dbg,error,
740 DW_DLE_RNGLISTS_ERROR,
741 dwarfstring_string(&m));
742 dwarfstring_destructor(&m);
743 return DW_DLV_ERROR;
744 }
745 {
746 dwarfstring m;
747
748 dwarfstring_constructor(&m);
749 dwarfstring_append_printf_u(&m,
750 "DW_DLE_RNGLISTS_ERROR: rnglist base of "
751 " 0x%" DW_PR_XZEROS DW_PR_DUx ,lookfor);
752 dwarfstring_append(&m,
753 " was not found anywhere in .debug_rnglists "
754 "data. Corrupted data?");
755 _dwarf_error_string(dbg,error,
756 DW_DLE_RNGLISTS_ERROR,
757 dwarfstring_string(&m));
758 dwarfstring_destructor(&m);
759 return DW_DLV_ERROR;
760 }
761 }
762 return DW_DLV_ERROR;
763 }
764
765 int
dwarf_dealloc_rnglists_head(Dwarf_Rnglists_Head h)766 dwarf_dealloc_rnglists_head(Dwarf_Rnglists_Head h)
767 {
768 Dwarf_Debug dbg = h->rh_dbg;
769
770 dwarf_dealloc(dbg,h,DW_DLA_RNGLISTS_HEAD);
771 return DW_DLV_OK;
772 }
773
774 /* Caller will eventually free as appropriate. */
775 static int
alloc_rle_and_append_to_list(Dwarf_Debug dbg,Dwarf_Rnglists_Head rctx,Dwarf_Rnglists_Entry * e_out,Dwarf_Error * error)776 alloc_rle_and_append_to_list(Dwarf_Debug dbg,
777 Dwarf_Rnglists_Head rctx,
778 Dwarf_Rnglists_Entry *e_out,
779 Dwarf_Error *error)
780 {
781 Dwarf_Rnglists_Entry e = 0;
782
783 e = malloc(sizeof(struct Dwarf_Rnglists_Entry_s));
784 if (!e) {
785 _dwarf_error_string(dbg, error, DW_DLE_ALLOC_FAIL,
786 "DW_DLE_ALLOC_FAIL: Out of memory in "
787 "building list of rnglists entries on a DIE.");
788 return DW_DLV_ERROR;
789 }
790 memset(e,0,sizeof(struct Dwarf_Rnglists_Entry_s));
791 if (rctx->rh_first) {
792 rctx->rh_last->rle_next = e;
793 rctx->rh_last = e;
794 } else {
795 rctx->rh_first = e;
796 rctx->rh_last = e;
797 }
798 rctx->rh_count++;
799 *e_out = e;
800 return DW_DLV_OK;
801 }
802
803 /* Read the group of rangelists entries, and
804 finally build an array of Dwarf_Rnglists_Entry
805 records. Attach to rctx here.
806 Since on error the caller will destruct the rctx
807 and we ensure to attach allocations there
808 the caller will destruct the allocations here
809 in case we return DW_DLV_ERROR*/
810 static int
build_array_of_rle(Dwarf_Debug dbg,Dwarf_Rnglists_Head rctx,Dwarf_Error * error)811 build_array_of_rle(Dwarf_Debug dbg,
812 Dwarf_Rnglists_Head rctx,
813 Dwarf_Error *error)
814 {
815 int res = 0;
816 Dwarf_Small * data = rctx->rh_rlepointer;
817 Dwarf_Unsigned dataoffset = rctx->rh_rlearea_offset;
818 Dwarf_Small *enddata = rctx->rh_end_data_area;
819 unsigned address_size = rctx->rh_address_size;
820 Dwarf_Unsigned bytescounttotal= 0;
821 Dwarf_Unsigned latestbaseaddr = 0;
822 unsigned foundbaseaddr = FALSE;
823 int done = FALSE;
824
825 if (rctx->rh_cu_base_address_present) {
826 /* The CU DIE had DW_AT_low_pc
827 and it is a base address. */
828 latestbaseaddr = rctx->rh_cu_base_address;
829 foundbaseaddr = TRUE;
830 }
831 for( ; !done ; ) {
832 unsigned entrylen = 0;
833 unsigned code = 0;
834 Dwarf_Unsigned val1 = 0;
835 Dwarf_Unsigned val2 = 0;
836 Dwarf_Addr addr1= 0;
837 Dwarf_Addr addr2 = 0;
838 Dwarf_Rnglists_Entry e = 0;
839
840 res = read_single_rle_entry(dbg,
841 data,dataoffset, enddata,
842 address_size,&entrylen,
843 &code,&val1, &val2,error);
844 if (res != DW_DLV_OK) {
845 return res;
846 }
847 res = alloc_rle_and_append_to_list(dbg,rctx,&e,error);
848 if (res != DW_DLV_OK) {
849 return res;
850 }
851 e->rle_code = code,
852 e->rle_entrylen = entrylen;
853 e->rle_raw1 = val1;
854 e->rle_raw2 = val2;
855 bytescounttotal += entrylen;
856 data += entrylen;
857 if (code == DW_RLE_end_of_list) {
858 done = TRUE;
859 break;
860 }
861 switch(code) {
862 case DW_RLE_base_addressx:
863 foundbaseaddr = TRUE;
864 res = _dwarf_extract_address_from_debug_addr(
865 dbg,rctx->rh_context,val1,
866 &addr1,error);
867 if (res != DW_DLV_OK) {
868 return res;
869 }
870 e->rle_cooked1 = addr1;
871 latestbaseaddr = addr1;
872 break;
873 case DW_RLE_startx_endx:
874 res = _dwarf_extract_address_from_debug_addr(
875 dbg,rctx->rh_context,val1,
876 &addr1,error);
877 if (res != DW_DLV_OK) {
878 return res;
879 }
880 res = _dwarf_extract_address_from_debug_addr(
881 dbg,rctx->rh_context,val2,
882 &addr2,error);
883 if (res != DW_DLV_OK) {
884 return res;
885 }
886 e->rle_cooked1 = addr1;
887 e->rle_cooked2 = addr2;
888 break;
889 case DW_RLE_startx_length:
890 res = _dwarf_extract_address_from_debug_addr(
891 dbg,rctx->rh_context,val1,
892 &addr1,error);
893 if (res != DW_DLV_OK) {
894 return res;
895 }
896 e->rle_cooked1 = addr1;
897 e->rle_cooked2 = val2+addr1;
898 break;
899 case DW_RLE_offset_pair:
900 if(foundbaseaddr) {
901 e->rle_cooked1 = val1+latestbaseaddr;
902 e->rle_cooked2 = val2+latestbaseaddr;
903 } else {
904 e->rle_cooked1 = val1+rctx->rh_cu_base_address;
905 e->rle_cooked2 = val2+rctx->rh_cu_base_address;
906 }
907 break;
908 case DW_RLE_base_address:
909 foundbaseaddr = TRUE;
910 latestbaseaddr = val1;
911 e->rle_cooked1 = val1;
912 break;
913 case DW_RLE_start_end:
914 e->rle_cooked1 = val1;
915 e->rle_cooked2 = val2;
916 break;
917 case DW_RLE_start_length:
918 e->rle_cooked1 = val1;
919 e->rle_cooked2 = val2+val1;
920 break;
921 default: {
922 dwarfstring m;
923
924 dwarfstring_constructor(&m);
925 dwarfstring_append_printf_u(&m,
926 " DW_DLE_RNGLISTS_ERROR: "
927 " The .debug_rnglists "
928 " rangelist code 0x%x is unknown, "
929 " DWARF5 is corrupted.",code);
930 _dwarf_error_string(dbg, error,
931 DW_DLE_RNGLISTS_ERROR,
932 dwarfstring_string(&m));
933 dwarfstring_destructor(&m);
934 return DW_DLV_ERROR;
935 }
936 }
937 }
938 if (rctx->rh_count > 0) {
939 Dwarf_Rnglists_Entry* array = 0;
940 Dwarf_Rnglists_Entry cur = 0;
941 Dwarf_Unsigned i = 0;
942
943 /* Creating an array of pointers. */
944 array = (Dwarf_Rnglists_Entry*)malloc(
945 rctx->rh_count *sizeof(Dwarf_Rnglists_Entry));
946 if (!array) {
947 _dwarf_error_string(dbg, error, DW_DLE_ALLOC_FAIL,
948 "DW_DLE_ALLOC_FAIL: Out of memory in "
949 "turning list of rnglists entries on a DIE"
950 "into a pointer array");
951 return DW_DLV_ERROR;
952 }
953 cur = rctx->rh_first;
954 for ( ; i < rctx->rh_count; ++i) {
955 array[i] = cur;
956 cur = cur->rle_next;
957 }
958 rctx->rh_rnglists = array;
959 rctx->rh_first = 0;
960 rctx->rh_last = 0;
961 }
962 rctx->rh_bytes_total = bytescounttotal;
963 return DW_DLV_OK;
964 }
965
966 /* Build a head with all the relevent Entries
967 attached.
968 */
969 int
dwarf_rnglists_get_rle_head(Dwarf_Attribute attr,Dwarf_Half theform,Dwarf_Unsigned attr_val,Dwarf_Rnglists_Head * head_out,Dwarf_Unsigned * entries_count_out,Dwarf_Unsigned * global_offset_of_rle_set,Dwarf_Error * error)970 dwarf_rnglists_get_rle_head(
971 Dwarf_Attribute attr,
972 Dwarf_Half theform,
973 Dwarf_Unsigned attr_val,
974 Dwarf_Rnglists_Head *head_out,
975 Dwarf_Unsigned *entries_count_out,
976 Dwarf_Unsigned *global_offset_of_rle_set,
977 Dwarf_Error *error)
978 {
979 int res = 0;
980 Dwarf_Unsigned rnglists_contextnum = 0;
981 Dwarf_Small *table_base = 0;
982 Dwarf_Small *table_entry = 0;
983 Dwarf_Small *enddata = 0;
984 Dwarf_Rnglists_Context *array = 0;
985 Dwarf_Rnglists_Context rctx = 0;
986 Dwarf_Unsigned entrycount = 0;
987 unsigned offsetsize = 0;
988 Dwarf_Unsigned rle_global_offset = 0;
989 Dwarf_Rnglists_Head lhead = 0;
990 Dwarf_CU_Context ctx = 0;
991 struct Dwarf_Rnglists_Head_s shead;
992 Dwarf_Unsigned offset_in_rnglists = 0;
993 Dwarf_Debug dbg = 0;
994 Dwarf_Bool is_rnglistx = FALSE;
995
996 memset(&shead,0,sizeof(shead));
997 ctx = attr->ar_cu_context;
998 dbg = ctx->cc_dbg;
999 array = dbg->de_rnglists_context;
1000 if (theform == DW_FORM_rnglistx) {
1001 is_rnglistx = TRUE;
1002 }
1003 /* ASSERT: the 3 pointers just set are non-null */
1004 /* the context cc_rnglists_base gives the offset
1005 of the array. of offsets (if cc_rnglists_base_present) */
1006 offset_in_rnglists = attr_val;
1007 if (is_rnglistx) {
1008 if (ctx->cc_rnglists_base_present) {
1009 offset_in_rnglists = ctx->cc_rnglists_base;
1010
1011 } else {
1012 /* FIXME: check in tied file for a cc_rnglists_base */
1013 dwarfstring m;
1014
1015 dwarfstring_constructor(&m);
1016 dwarfstring_append_printf_u(&m,
1017 "DW_DLE_RNGLISTS_ERROR: rnglists table index of"
1018 " %u" ,attr_val);
1019 dwarfstring_append(&m,
1020 " is unusable unless it is in a tied file."
1021 " libdwarf is incomplete. FIXME");
1022 _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,
1023 dwarfstring_string(&m));
1024 dwarfstring_destructor(&m);
1025 return DW_DLV_ERROR;
1026 }
1027 } else {
1028 offset_in_rnglists = attr_val;
1029 }
1030 res = _dwarf_which_rnglists_context(dbg,ctx,
1031 offset_in_rnglists,
1032 &rnglists_contextnum,error);
1033 if (res != DW_DLV_OK) {
1034 return res;
1035 }
1036 rctx = array[rnglists_contextnum];
1037 table_base = rctx->rc_offsets_array;
1038 entrycount = rctx->rc_offset_entry_count;
1039 offsetsize = rctx->rc_offset_size;
1040 enddata = rctx->rc_endaddr;
1041
1042 if (is_rnglistx && attr_val >= entrycount) {
1043 dwarfstring m;
1044
1045 dwarfstring_constructor(&m);
1046 dwarfstring_append_printf_u(&m,
1047 "DW_DLE_RNGLISTS_ERROR: rnglists table index of"
1048 " %u" ,attr_val);
1049 dwarfstring_append_printf_u(&m,
1050 " too large for table of %u "
1051 "entries.",entrycount);
1052 _dwarf_error_string(dbg,error,
1053 DW_DLE_RNGLISTS_ERROR,
1054 dwarfstring_string(&m));
1055 dwarfstring_destructor(&m);
1056 return DW_DLV_ERROR;
1057 }
1058 shead.rh_context = ctx;
1059 shead.rh_localcontext = rctx;
1060 shead.rh_index = rnglists_contextnum;
1061 shead.rh_version = rctx->rc_version;
1062 shead.rh_offset_size = offsetsize;
1063 shead.rh_address_size = rctx->rc_address_size;
1064 shead.rh_segment_selector_size =
1065 rctx->rc_segment_selector_size;
1066
1067 /* DW_AT_rnglists_base from CU */
1068 shead.rh_at_rnglists_base_present =
1069 ctx->cc_rnglists_base_present;
1070 shead.rh_at_rnglists_base = ctx->cc_rnglists_base;
1071
1072 /* DW_AT_low_pc, if present. From CU */
1073 shead.rh_cu_base_address_present = ctx->cc_low_pc_present;
1074 shead.rh_cu_base_address = ctx->cc_low_pc;
1075
1076 /* base address DW_AT_addr_base of our part of
1077 .debug_addr, from CU */
1078 shead.rh_cu_addr_base = ctx->cc_addr_base;
1079 shead.rh_cu_addr_base_present = ctx->cc_addr_base_present;
1080 if (is_rnglistx) {
1081 Dwarf_Unsigned table_entryval = 0;
1082
1083 table_entry = attr_val*offsetsize + table_base;
1084 /* No malloc here yet so no leak if the macro returns
1085 DW_DLV_ERROR */
1086 READ_UNALIGNED_CK(dbg,table_entryval, Dwarf_Unsigned,
1087 table_entry,offsetsize,error,enddata);
1088 rle_global_offset = rctx->rc_offsets_off_in_sect +
1089 table_entryval;
1090 } else {
1091 rle_global_offset = attr_val;
1092 }
1093
1094 shead.rh_rlepointer = rctx->rc_offsets_array +
1095 rctx->rc_offset_entry_count*offsetsize;
1096 shead.rh_end_data_area = enddata;
1097
1098 shead.rh_rlearea_offset = rle_global_offset;
1099 shead.rh_rlepointer = rle_global_offset +
1100 dbg->de_debug_rnglists.dss_data;
1101 lhead = (Dwarf_Rnglists_Head)
1102 _dwarf_get_alloc(dbg,DW_DLA_RNGLISTS_HEAD,1);
1103 if (!lhead) {
1104 _dwarf_error_string(dbg, error, DW_DLE_ALLOC_FAIL,
1105 "Allocating a Dwarf_Rnglists_Head struct fails"
1106 " in libdwarf function dwarf_rnglists_index_get_rle_head()");
1107 return DW_DLV_ERROR;
1108 }
1109 shead.rh_dbg = dbg;
1110 *lhead = shead;
1111 res = build_array_of_rle(dbg,lhead,error);
1112 if (res != DW_DLV_OK) {
1113 dwarf_dealloc(dbg,lhead,DW_DLA_RNGLISTS_HEAD);
1114 return res;
1115 }
1116 if(global_offset_of_rle_set) {
1117 *global_offset_of_rle_set = rle_global_offset;
1118 }
1119 /* Caller needs the head pointer else there will be leaks. */
1120 *head_out = lhead;
1121 if (entries_count_out) {
1122 *entries_count_out = lhead->rh_count;
1123 }
1124 return DW_DLV_OK;
1125 }
1126
1127 int
dwarf_get_rnglists_entry_fields(Dwarf_Rnglists_Head head,Dwarf_Unsigned entrynum,unsigned * entrylen,unsigned * code,Dwarf_Unsigned * raw1,Dwarf_Unsigned * raw2,Dwarf_Unsigned * cooked1,Dwarf_Unsigned * cooked2,UNUSEDARG Dwarf_Error * err)1128 dwarf_get_rnglists_entry_fields(
1129 Dwarf_Rnglists_Head head,
1130 Dwarf_Unsigned entrynum,
1131 unsigned *entrylen,
1132 unsigned *code,
1133 Dwarf_Unsigned *raw1,
1134 Dwarf_Unsigned *raw2,
1135 Dwarf_Unsigned *cooked1,
1136 Dwarf_Unsigned *cooked2,
1137 UNUSEDARG Dwarf_Error *err)
1138 {
1139 Dwarf_Rnglists_Entry e = 0;
1140
1141 if (entrynum >= head->rh_count) {
1142 return DW_DLV_NO_ENTRY;
1143 }
1144 e = head->rh_rnglists[entrynum];
1145 *entrylen = e->rle_entrylen;
1146 *code = e->rle_code;
1147 *raw1 = e->rle_raw1;
1148 *raw2 = e->rle_raw2;
1149 *cooked1 = e->rle_cooked1;
1150 *cooked2 = e->rle_cooked2;
1151 return DW_DLV_OK;
1152 }
1153
1154 /* Deals with both fully and partially build head */
1155 static void
_dwarf_free_rnglists_head(Dwarf_Rnglists_Head head)1156 _dwarf_free_rnglists_head(Dwarf_Rnglists_Head head)
1157 {
1158 if (head->rh_first) {
1159 /* partially built head. */
1160 /* ASSERT: rh_rnglists is NULL */
1161 Dwarf_Rnglists_Entry cur = head->rh_first;
1162 Dwarf_Rnglists_Entry next = 0;
1163
1164 for ( ; cur ; cur = next) {
1165 next = cur->rle_next;
1166 free(cur);
1167 }
1168 head->rh_first = 0;
1169 head->rh_last = 0;
1170 head->rh_count = 0;
1171 } else {
1172 /* ASSERT: rh_first and rh_last are NULL */
1173 /* fully built head. */
1174 Dwarf_Unsigned i = 0;
1175
1176 /* Deal with the array form. */
1177 for( ; i < head->rh_count; ++i) {
1178 free(head->rh_rnglists[i]);
1179 }
1180 free(head->rh_rnglists);
1181 head->rh_rnglists = 0;
1182 }
1183 }
1184
1185 void
_dwarf_rnglists_head_destructor(void * head)1186 _dwarf_rnglists_head_destructor(void *head)
1187 {
1188 Dwarf_Rnglists_Head h = head;
1189
1190 _dwarf_free_rnglists_head(h);
1191 }
1192