1 /* DWARF 1 find nearest line (_bfd_dwarf1_find_nearest_line).
2 Copyright (C) 1998-2021 Free Software Foundation, Inc.
3
4 Written by Gavin Romig-Koch of Cygnus Solutions (gavin@cygnus.com).
5
6 This file is part of BFD.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or (at
11 your option) any later version.
12
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "libiberty.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "elf/dwarf.h"
29
30 /* dwarf1_debug is the starting point for all dwarf1 info. */
31
32 struct dwarf1_debug
33 {
34 /* The bfd we are working with. */
35 bfd* abfd;
36
37 /* Pointer to the symbol table. */
38 asymbol** syms;
39
40 /* List of already parsed compilation units. */
41 struct dwarf1_unit* lastUnit;
42
43 /* The buffer for the .debug section.
44 Zero indicates that the .debug section failed to load. */
45 bfd_byte *debug_section;
46
47 /* Pointer to the end of the .debug_info section memory buffer. */
48 bfd_byte *debug_section_end;
49
50 /* The buffer for the .line section. */
51 bfd_byte *line_section;
52
53 /* End of that buffer. */
54 bfd_byte *line_section_end;
55
56 /* The current or next unread die within the .debug section. */
57 bfd_byte *currentDie;
58 };
59
60 /* One dwarf1_unit for each parsed compilation unit die. */
61
62 struct dwarf1_unit
63 {
64 /* Linked starting from stash->lastUnit. */
65 struct dwarf1_unit* prev;
66
67 /* Name of the compilation unit. */
68 char *name;
69
70 /* The highest and lowest address used in the compilation unit. */
71 unsigned long low_pc;
72 unsigned long high_pc;
73
74 /* Does this unit have a statement list? */
75 int has_stmt_list;
76
77 /* If any, the offset of the line number table in the .line section. */
78 unsigned long stmt_list_offset;
79
80 /* If non-zero, a pointer to the first child of this unit. */
81 bfd_byte *first_child;
82
83 /* How many line entries? */
84 unsigned long line_count;
85
86 /* The decoded line number table (line_count entries). */
87 struct linenumber* linenumber_table;
88
89 /* The list of functions in this unit. */
90 struct dwarf1_func* func_list;
91 };
92
93 /* One dwarf1_func for each parsed function die. */
94
95 struct dwarf1_func
96 {
97 /* Linked starting from aUnit->func_list. */
98 struct dwarf1_func* prev;
99
100 /* Name of function. */
101 char* name;
102
103 /* The highest and lowest address used in the compilation unit. */
104 unsigned long low_pc;
105 unsigned long high_pc;
106 };
107
108 /* Used to return info about a parsed die. */
109 struct die_info
110 {
111 unsigned long length;
112 unsigned long sibling;
113 unsigned long low_pc;
114 unsigned long high_pc;
115 unsigned long stmt_list_offset;
116
117 char* name;
118
119 int has_stmt_list;
120
121 unsigned short tag;
122 };
123
124 /* Parsed line number information. */
125 struct linenumber
126 {
127 /* First address in the line. */
128 unsigned long addr;
129
130 /* The line number. */
131 unsigned long linenumber;
132 };
133
134 /* Find the form of an attr, from the attr field. */
135 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified. */
136
137 /* Return a newly allocated dwarf1_unit. It should be cleared and
138 then attached into the 'stash' at 'stash->lastUnit'. */
139
140 static struct dwarf1_unit*
alloc_dwarf1_unit(struct dwarf1_debug * stash)141 alloc_dwarf1_unit (struct dwarf1_debug* stash)
142 {
143 size_t amt = sizeof (struct dwarf1_unit);
144
145 struct dwarf1_unit* x = (struct dwarf1_unit *) bfd_zalloc (stash->abfd, amt);
146 if (x)
147 {
148 x->prev = stash->lastUnit;
149 stash->lastUnit = x;
150 }
151
152 return x;
153 }
154
155 /* Return a newly allocated dwarf1_func. It must be cleared and
156 attached into 'aUnit' at 'aUnit->func_list'. */
157
158 static struct dwarf1_func *
alloc_dwarf1_func(struct dwarf1_debug * stash,struct dwarf1_unit * aUnit)159 alloc_dwarf1_func (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
160 {
161 size_t amt = sizeof (struct dwarf1_func);
162
163 struct dwarf1_func* x = (struct dwarf1_func *) bfd_zalloc (stash->abfd, amt);
164 if (x)
165 {
166 x->prev = aUnit->func_list;
167 aUnit->func_list = x;
168 }
169
170 return x;
171 }
172
173 /* parse_die - parse a Dwarf1 die.
174 Parse the die starting at 'aDiePtr' into 'aDieInfo'.
175 'abfd' must be the bfd from which the section that 'aDiePtr'
176 points to was pulled from.
177
178 Return FALSE if the die is invalidly formatted; TRUE otherwise. */
179
180 static bool
parse_die(bfd * abfd,struct die_info * aDieInfo,bfd_byte * aDiePtr,bfd_byte * aDiePtrEnd)181 parse_die (bfd * abfd,
182 struct die_info * aDieInfo,
183 bfd_byte * aDiePtr,
184 bfd_byte * aDiePtrEnd)
185 {
186 bfd_byte *this_die = aDiePtr;
187 bfd_byte *xptr = this_die;
188
189 memset (aDieInfo, 0, sizeof (* aDieInfo));
190
191 /* First comes the length. */
192 if (xptr + 4 > aDiePtrEnd)
193 return false;
194 aDieInfo->length = bfd_get_32 (abfd, xptr);
195 xptr += 4;
196 if (aDieInfo->length == 0
197 || this_die + aDieInfo->length > aDiePtrEnd)
198 return false;
199 aDiePtrEnd = this_die + aDieInfo->length;
200 if (aDieInfo->length < 6)
201 {
202 /* Just padding bytes. */
203 aDieInfo->tag = TAG_padding;
204 return true;
205 }
206
207 /* Then the tag. */
208 if (xptr + 2 > aDiePtrEnd)
209 return false;
210 aDieInfo->tag = bfd_get_16 (abfd, xptr);
211 xptr += 2;
212
213 /* Then the attributes. */
214 while (xptr + 2 <= aDiePtrEnd)
215 {
216 unsigned int block_len;
217 unsigned short attr;
218
219 /* Parse the attribute based on its form. This section
220 must handle all dwarf1 forms, but need only handle the
221 actual attributes that we care about. */
222 attr = bfd_get_16 (abfd, xptr);
223 xptr += 2;
224
225 switch (FORM_FROM_ATTR (attr))
226 {
227 case FORM_DATA2:
228 xptr += 2;
229 break;
230 case FORM_DATA4:
231 case FORM_REF:
232 if (xptr + 4 <= aDiePtrEnd)
233 {
234 if (attr == AT_sibling)
235 aDieInfo->sibling = bfd_get_32 (abfd, xptr);
236 else if (attr == AT_stmt_list)
237 {
238 aDieInfo->stmt_list_offset = bfd_get_32 (abfd, xptr);
239 aDieInfo->has_stmt_list = 1;
240 }
241 }
242 xptr += 4;
243 break;
244 case FORM_DATA8:
245 xptr += 8;
246 break;
247 case FORM_ADDR:
248 if (xptr + 4 <= aDiePtrEnd)
249 {
250 if (attr == AT_low_pc)
251 aDieInfo->low_pc = bfd_get_32 (abfd, xptr);
252 else if (attr == AT_high_pc)
253 aDieInfo->high_pc = bfd_get_32 (abfd, xptr);
254 }
255 xptr += 4;
256 break;
257 case FORM_BLOCK2:
258 if (xptr + 2 <= aDiePtrEnd)
259 {
260 block_len = bfd_get_16 (abfd, xptr);
261 if (xptr + block_len > aDiePtrEnd
262 || xptr + block_len < xptr)
263 return false;
264 xptr += block_len;
265 }
266 xptr += 2;
267 break;
268 case FORM_BLOCK4:
269 if (xptr + 4 <= aDiePtrEnd)
270 {
271 block_len = bfd_get_32 (abfd, xptr);
272 if (xptr + block_len > aDiePtrEnd
273 || xptr + block_len < xptr)
274 return false;
275 xptr += block_len;
276 }
277 xptr += 4;
278 break;
279 case FORM_STRING:
280 if (attr == AT_name)
281 aDieInfo->name = (char *) xptr;
282 xptr += strnlen ((char *) xptr, aDiePtrEnd - xptr) + 1;
283 break;
284 }
285 }
286
287 return true;
288 }
289
290 /* Parse a dwarf1 line number table for 'aUnit->stmt_list_offset'
291 into 'aUnit->linenumber_table'. Return FALSE if an error
292 occurs; TRUE otherwise. */
293
294 static bool
parse_line_table(struct dwarf1_debug * stash,struct dwarf1_unit * aUnit)295 parse_line_table (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
296 {
297 bfd_byte *xptr;
298
299 /* Load the ".line" section from the bfd if we haven't already. */
300 if (stash->line_section == 0)
301 {
302 asection *msec;
303 bfd_size_type size;
304
305 msec = bfd_get_section_by_name (stash->abfd, ".line");
306 if (! msec)
307 return false;
308
309 size = msec->rawsize ? msec->rawsize : msec->size;
310 stash->line_section
311 = bfd_simple_get_relocated_section_contents
312 (stash->abfd, msec, NULL, stash->syms);
313
314 if (! stash->line_section)
315 return false;
316
317 stash->line_section_end = stash->line_section + size;
318 }
319
320 xptr = stash->line_section + aUnit->stmt_list_offset;
321 if (xptr + 8 <= stash->line_section_end)
322 {
323 unsigned long eachLine;
324 bfd_byte *tblend;
325 unsigned long base;
326 bfd_size_type amt;
327
328 /* First comes the length. */
329 tblend = bfd_get_32 (stash->abfd, (bfd_byte *) xptr) + xptr;
330 xptr += 4;
331
332 /* Then the base address for each address in the table. */
333 base = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
334 xptr += 4;
335
336 /* How many line entrys?
337 10 = 4 (line number) + 2 (pos in line) + 4 (address in line). */
338 aUnit->line_count = (tblend - xptr) / 10;
339
340 /* Allocate an array for the entries. */
341 amt = sizeof (struct linenumber) * aUnit->line_count;
342 aUnit->linenumber_table = (struct linenumber *) bfd_alloc (stash->abfd,
343 amt);
344 if (!aUnit->linenumber_table)
345 return false;
346
347 for (eachLine = 0; eachLine < aUnit->line_count; eachLine++)
348 {
349 if (xptr + 10 > stash->line_section_end)
350 {
351 aUnit->line_count = eachLine;
352 break;
353 }
354 /* A line number. */
355 aUnit->linenumber_table[eachLine].linenumber
356 = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
357 xptr += 4;
358
359 /* Skip the position within the line. */
360 xptr += 2;
361
362 /* And finally the address. */
363 aUnit->linenumber_table[eachLine].addr
364 = base + bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
365 xptr += 4;
366 }
367 }
368
369 return true;
370 }
371
372 /* Parse each function die in a compilation unit 'aUnit'.
373 The first child die of 'aUnit' should be in 'aUnit->first_child',
374 the result is placed in 'aUnit->func_list'.
375 Return FALSE if error; TRUE otherwise. */
376
377 static bool
parse_functions_in_unit(struct dwarf1_debug * stash,struct dwarf1_unit * aUnit)378 parse_functions_in_unit (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
379 {
380 bfd_byte *eachDie;
381
382 if (aUnit->first_child)
383 for (eachDie = aUnit->first_child;
384 eachDie < stash->debug_section_end;
385 )
386 {
387 struct die_info eachDieInfo;
388
389 if (! parse_die (stash->abfd, &eachDieInfo, eachDie,
390 stash->debug_section_end))
391 return false;
392
393 if (eachDieInfo.tag == TAG_global_subroutine
394 || eachDieInfo.tag == TAG_subroutine
395 || eachDieInfo.tag == TAG_inlined_subroutine
396 || eachDieInfo.tag == TAG_entry_point)
397 {
398 struct dwarf1_func* aFunc = alloc_dwarf1_func (stash,aUnit);
399 if (!aFunc)
400 return false;
401
402 aFunc->name = eachDieInfo.name;
403 aFunc->low_pc = eachDieInfo.low_pc;
404 aFunc->high_pc = eachDieInfo.high_pc;
405 }
406
407 /* Move to next sibling, if none, end loop */
408 if (eachDieInfo.sibling)
409 eachDie = stash->debug_section + eachDieInfo.sibling;
410 else
411 break;
412 }
413
414 return true;
415 }
416
417 /* Find the nearest line to 'addr' in 'aUnit'.
418 Return whether we found the line (or a function) without error. */
419
420 static bool
dwarf1_unit_find_nearest_line(struct dwarf1_debug * stash,struct dwarf1_unit * aUnit,unsigned long addr,const char ** filename_ptr,const char ** functionname_ptr,unsigned int * linenumber_ptr)421 dwarf1_unit_find_nearest_line (struct dwarf1_debug* stash,
422 struct dwarf1_unit* aUnit,
423 unsigned long addr,
424 const char **filename_ptr,
425 const char **functionname_ptr,
426 unsigned int *linenumber_ptr)
427 {
428 int line_p = false;
429 int func_p = false;
430
431 if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
432 {
433 if (aUnit->has_stmt_list)
434 {
435 unsigned long i;
436 struct dwarf1_func* eachFunc;
437
438 if (! aUnit->linenumber_table)
439 {
440 if (! parse_line_table (stash, aUnit))
441 return false;
442 }
443
444 if (! aUnit->func_list)
445 {
446 if (! parse_functions_in_unit (stash, aUnit))
447 return false;
448 }
449
450 for (i = 0; i < aUnit->line_count; i++)
451 {
452 if (aUnit->linenumber_table[i].addr <= addr
453 && addr < aUnit->linenumber_table[i+1].addr)
454 {
455 *filename_ptr = aUnit->name;
456 *linenumber_ptr = aUnit->linenumber_table[i].linenumber;
457 line_p = true;
458 break;
459 }
460 }
461
462 for (eachFunc = aUnit->func_list;
463 eachFunc;
464 eachFunc = eachFunc->prev)
465 {
466 if (eachFunc->low_pc <= addr
467 && addr < eachFunc->high_pc)
468 {
469 *functionname_ptr = eachFunc->name;
470 func_p = true;
471 break;
472 }
473 }
474 }
475 }
476
477 return line_p || func_p;
478 }
479
480 /* The DWARF 1 version of find_nearest line.
481 Return TRUE if the line is found without error. */
482
483 bool
_bfd_dwarf1_find_nearest_line(bfd * abfd,asymbol ** symbols,asection * section,bfd_vma offset,const char ** filename_ptr,const char ** functionname_ptr,unsigned int * linenumber_ptr)484 _bfd_dwarf1_find_nearest_line (bfd *abfd,
485 asymbol **symbols,
486 asection *section,
487 bfd_vma offset,
488 const char **filename_ptr,
489 const char **functionname_ptr,
490 unsigned int *linenumber_ptr)
491 {
492 struct dwarf1_debug *stash = elf_tdata (abfd)->dwarf1_find_line_info;
493
494 struct dwarf1_unit* eachUnit;
495
496 /* What address are we looking for? */
497 unsigned long addr = (unsigned long)(offset + section->vma);
498
499 *filename_ptr = NULL;
500 *functionname_ptr = NULL;
501 *linenumber_ptr = 0;
502
503 if (! stash)
504 {
505 asection *msec;
506 bfd_size_type size = sizeof (struct dwarf1_debug);
507
508 stash = elf_tdata (abfd)->dwarf1_find_line_info
509 = (struct dwarf1_debug *) bfd_zalloc (abfd, size);
510
511 if (! stash)
512 return false;
513
514 msec = bfd_get_section_by_name (abfd, ".debug");
515 if (! msec)
516 /* No dwarf1 info. Note that at this point the stash
517 has been allocated, but contains zeros, this lets
518 future calls to this function fail quicker. */
519 return false;
520
521 size = msec->rawsize ? msec->rawsize : msec->size;
522 stash->debug_section
523 = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
524 symbols);
525
526 if (! stash->debug_section)
527 return false;
528
529 stash->debug_section_end = stash->debug_section + size;
530 stash->currentDie = stash->debug_section;
531 stash->abfd = abfd;
532 stash->syms = symbols;
533 }
534
535 /* A null debug_section indicates that there was no dwarf1 info
536 or that an error occured while setting up the stash. */
537
538 if (! stash->debug_section)
539 return false;
540
541 /* Look at the previously parsed units to see if any contain
542 the addr. */
543 for (eachUnit = stash->lastUnit; eachUnit; eachUnit = eachUnit->prev)
544 if (eachUnit->low_pc <= addr && addr < eachUnit->high_pc)
545 return dwarf1_unit_find_nearest_line (stash, eachUnit, addr,
546 filename_ptr,
547 functionname_ptr,
548 linenumber_ptr);
549
550 while (stash->currentDie < stash->debug_section_end)
551 {
552 struct die_info aDieInfo;
553
554 if (! parse_die (stash->abfd, &aDieInfo, stash->currentDie,
555 stash->debug_section_end))
556 return false;
557
558 if (aDieInfo.tag == TAG_compile_unit)
559 {
560 struct dwarf1_unit* aUnit
561 = alloc_dwarf1_unit (stash);
562 if (!aUnit)
563 return false;
564
565 aUnit->name = aDieInfo.name;
566 aUnit->low_pc = aDieInfo.low_pc;
567 aUnit->high_pc = aDieInfo.high_pc;
568 aUnit->has_stmt_list = aDieInfo.has_stmt_list;
569 aUnit->stmt_list_offset = aDieInfo.stmt_list_offset;
570
571 /* A die has a child if it's followed by a die that is
572 not it's sibling. */
573 if (aDieInfo.sibling
574 && stash->currentDie + aDieInfo.length
575 < stash->debug_section_end
576 && stash->currentDie + aDieInfo.length
577 != stash->debug_section + aDieInfo.sibling)
578 aUnit->first_child = stash->currentDie + aDieInfo.length;
579 else
580 aUnit->first_child = 0;
581
582 if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
583 return dwarf1_unit_find_nearest_line (stash, aUnit, addr,
584 filename_ptr,
585 functionname_ptr,
586 linenumber_ptr);
587 }
588
589 if (aDieInfo.sibling != 0)
590 stash->currentDie = stash->debug_section + aDieInfo.sibling;
591 else
592 stash->currentDie += aDieInfo.length;
593 }
594
595 return false;
596 }
597