File: | src/gnu/usr.bin/binutils/bfd/dwarf2.c |
Warning: | line 1525, column 22 Assigned value is garbage or undefined |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* DWARF 2 support. | |||
2 | Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, | |||
3 | 2004 Free Software Foundation, Inc. | |||
4 | ||||
5 | Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions | |||
6 | (gavin@cygnus.com). | |||
7 | ||||
8 | From the dwarf2read.c header: | |||
9 | Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology, | |||
10 | Inc. with support from Florida State University (under contract | |||
11 | with the Ada Joint Program Office), and Silicon Graphics, Inc. | |||
12 | Initial contribution by Brent Benson, Harris Computer Systems, Inc., | |||
13 | based on Fred Fish's (Cygnus Support) implementation of DWARF 1 | |||
14 | support in dwarfread.c | |||
15 | ||||
16 | This file is part of BFD. | |||
17 | ||||
18 | This program is free software; you can redistribute it and/or modify | |||
19 | it under the terms of the GNU General Public License as published by | |||
20 | the Free Software Foundation; either version 2 of the License, or (at | |||
21 | your option) any later version. | |||
22 | ||||
23 | This program is distributed in the hope that it will be useful, but | |||
24 | WITHOUT ANY WARRANTY; without even the implied warranty of | |||
25 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
26 | General Public License for more details. | |||
27 | ||||
28 | You should have received a copy of the GNU General Public License | |||
29 | along with this program; if not, write to the Free Software | |||
30 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |||
31 | ||||
32 | #include "bfd.h" | |||
33 | #include "sysdep.h" | |||
34 | #include "libiberty.h" | |||
35 | #include "libbfd.h" | |||
36 | #include "elf-bfd.h" | |||
37 | #include "elf/dwarf2.h" | |||
38 | ||||
39 | /* The data in the .debug_line statement prologue looks like this. */ | |||
40 | ||||
41 | struct line_head | |||
42 | { | |||
43 | bfd_vma total_length; | |||
44 | unsigned short version; | |||
45 | bfd_vma prologue_length; | |||
46 | unsigned char minimum_instruction_length; | |||
47 | unsigned char default_is_stmt; | |||
48 | int line_base; | |||
49 | unsigned char line_range; | |||
50 | unsigned char opcode_base; | |||
51 | unsigned char *standard_opcode_lengths; | |||
52 | }; | |||
53 | ||||
54 | /* Attributes have a name and a value. */ | |||
55 | ||||
56 | struct attribute | |||
57 | { | |||
58 | enum dwarf_attribute name; | |||
59 | enum dwarf_form form; | |||
60 | union | |||
61 | { | |||
62 | char *str; | |||
63 | struct dwarf_block *blk; | |||
64 | bfd_uint64_t val; | |||
65 | bfd_int64_t sval; | |||
66 | } | |||
67 | u; | |||
68 | }; | |||
69 | ||||
70 | /* Blocks are a bunch of untyped bytes. */ | |||
71 | struct dwarf_block | |||
72 | { | |||
73 | unsigned int size; | |||
74 | char *data; | |||
75 | }; | |||
76 | ||||
77 | struct dwarf2_debug | |||
78 | { | |||
79 | /* A list of all previously read comp_units. */ | |||
80 | struct comp_unit* all_comp_units; | |||
81 | ||||
82 | /* The next unread compilation unit within the .debug_info section. | |||
83 | Zero indicates that the .debug_info section has not been loaded | |||
84 | into a buffer yet. */ | |||
85 | char* info_ptr; | |||
86 | ||||
87 | /* Pointer to the end of the .debug_info section memory buffer. */ | |||
88 | char* info_ptr_end; | |||
89 | ||||
90 | /* Pointer to the section and address of the beginning of the | |||
91 | section. */ | |||
92 | asection* sec; | |||
93 | char* sec_info_ptr; | |||
94 | ||||
95 | /* Pointer to the symbol table. */ | |||
96 | asymbol** syms; | |||
97 | ||||
98 | /* Pointer to the .debug_abbrev section loaded into memory. */ | |||
99 | char* dwarf_abbrev_buffer; | |||
100 | ||||
101 | /* Length of the loaded .debug_abbrev section. */ | |||
102 | unsigned long dwarf_abbrev_size; | |||
103 | ||||
104 | /* Buffer for decode_line_info. */ | |||
105 | char *dwarf_line_buffer; | |||
106 | ||||
107 | /* Length of the loaded .debug_line section. */ | |||
108 | unsigned long dwarf_line_size; | |||
109 | ||||
110 | /* Pointer to the .debug_str section loaded into memory. */ | |||
111 | char* dwarf_str_buffer; | |||
112 | ||||
113 | /* Length of the loaded .debug_str section. */ | |||
114 | unsigned long dwarf_str_size; | |||
115 | }; | |||
116 | ||||
117 | struct arange | |||
118 | { | |||
119 | struct arange *next; | |||
120 | bfd_vma low; | |||
121 | bfd_vma high; | |||
122 | }; | |||
123 | ||||
124 | /* A minimal decoding of DWARF2 compilation units. We only decode | |||
125 | what's needed to get to the line number information. */ | |||
126 | ||||
127 | struct comp_unit | |||
128 | { | |||
129 | /* Chain the previously read compilation units. */ | |||
130 | struct comp_unit* next_unit; | |||
131 | ||||
132 | /* Keep the bdf convenient (for memory allocation). */ | |||
133 | bfd* abfd; | |||
134 | ||||
135 | /* The lowest and higest addresses contained in this compilation | |||
136 | unit as specified in the compilation unit header. */ | |||
137 | struct arange arange; | |||
138 | ||||
139 | /* The DW_AT_name attribute (for error messages). */ | |||
140 | char* name; | |||
141 | ||||
142 | /* The abbrev hash table. */ | |||
143 | struct abbrev_info** abbrevs; | |||
144 | ||||
145 | /* Note that an error was found by comp_unit_find_nearest_line. */ | |||
146 | int error; | |||
147 | ||||
148 | /* The DW_AT_comp_dir attribute. */ | |||
149 | char* comp_dir; | |||
150 | ||||
151 | /* TRUE if there is a line number table associated with this comp. unit. */ | |||
152 | int stmtlist; | |||
153 | ||||
154 | /* The offset into .debug_line of the line number table. */ | |||
155 | unsigned long line_offset; | |||
156 | ||||
157 | /* Pointer to the first child die for the comp unit. */ | |||
158 | char *first_child_die_ptr; | |||
159 | ||||
160 | /* The end of the comp unit. */ | |||
161 | char *end_ptr; | |||
162 | ||||
163 | /* The decoded line number, NULL if not yet decoded. */ | |||
164 | struct line_info_table* line_table; | |||
165 | ||||
166 | /* A list of the functions found in this comp. unit. */ | |||
167 | struct funcinfo* function_table; | |||
168 | ||||
169 | /* Pointer to dwarf2_debug structure. */ | |||
170 | struct dwarf2_debug *stash; | |||
171 | ||||
172 | /* Address size for this unit - from unit header. */ | |||
173 | unsigned char addr_size; | |||
174 | ||||
175 | /* Offset size for this unit - from unit header. */ | |||
176 | unsigned char offset_size; | |||
177 | }; | |||
178 | ||||
179 | /* This data structure holds the information of an abbrev. */ | |||
180 | struct abbrev_info | |||
181 | { | |||
182 | unsigned int number; /* Number identifying abbrev. */ | |||
183 | enum dwarf_tag tag; /* DWARF tag. */ | |||
184 | int has_children; /* Boolean. */ | |||
185 | unsigned int num_attrs; /* Number of attributes. */ | |||
186 | struct attr_abbrev *attrs; /* An array of attribute descriptions. */ | |||
187 | struct abbrev_info *next; /* Next in chain. */ | |||
188 | }; | |||
189 | ||||
190 | struct attr_abbrev | |||
191 | { | |||
192 | enum dwarf_attribute name; | |||
193 | enum dwarf_form form; | |||
194 | }; | |||
195 | ||||
196 | #ifndef ABBREV_HASH_SIZE121 | |||
197 | #define ABBREV_HASH_SIZE121 121 | |||
198 | #endif | |||
199 | #ifndef ATTR_ALLOC_CHUNK4 | |||
200 | #define ATTR_ALLOC_CHUNK4 4 | |||
201 | #endif | |||
202 | ||||
203 | /* VERBATIM | |||
204 | The following function up to the END VERBATIM mark are | |||
205 | copied directly from dwarf2read.c. */ | |||
206 | ||||
207 | /* Read dwarf information from a buffer. */ | |||
208 | ||||
209 | static unsigned int | |||
210 | read_1_byte (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), char *buf) | |||
211 | { | |||
212 | return bfd_get_8 (abfd, buf)(*(unsigned char *) (buf) & 0xff); | |||
213 | } | |||
214 | ||||
215 | static int | |||
216 | read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), char *buf) | |||
217 | { | |||
218 | return bfd_get_signed_8 (abfd, buf)(((*(unsigned char *) (buf) & 0xff) ^ 0x80) - 0x80); | |||
219 | } | |||
220 | ||||
221 | static unsigned int | |||
222 | read_2_bytes (bfd *abfd, char *buf) | |||
223 | { | |||
224 | return bfd_get_16 (abfd, buf)((*((abfd)->xvec->bfd_getx16)) (buf)); | |||
225 | } | |||
226 | ||||
227 | static unsigned int | |||
228 | read_4_bytes (bfd *abfd, char *buf) | |||
229 | { | |||
230 | return bfd_get_32 (abfd, buf)((*((abfd)->xvec->bfd_getx32)) (buf)); | |||
231 | } | |||
232 | ||||
233 | static bfd_uint64_t | |||
234 | read_8_bytes (bfd *abfd, char *buf) | |||
235 | { | |||
236 | return bfd_get_64 (abfd, buf)((*((abfd)->xvec->bfd_getx64)) (buf)); | |||
237 | } | |||
238 | ||||
239 | static char * | |||
240 | read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), | |||
241 | char *buf, | |||
242 | unsigned int size ATTRIBUTE_UNUSED__attribute__ ((__unused__))) | |||
243 | { | |||
244 | /* If the size of a host char is 8 bits, we can return a pointer | |||
245 | to the buffer, otherwise we have to copy the data to a buffer | |||
246 | allocated on the temporary obstack. */ | |||
247 | return buf; | |||
248 | } | |||
249 | ||||
250 | static char * | |||
251 | read_string (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), | |||
252 | char *buf, | |||
253 | unsigned int *bytes_read_ptr) | |||
254 | { | |||
255 | /* Return a pointer to the embedded string. */ | |||
256 | if (*buf == '\0') | |||
257 | { | |||
258 | *bytes_read_ptr = 1; | |||
259 | return NULL((void*)0); | |||
260 | } | |||
261 | ||||
262 | *bytes_read_ptr = strlen (buf) + 1; | |||
263 | return buf; | |||
264 | } | |||
265 | ||||
266 | static char * | |||
267 | read_indirect_string (struct comp_unit* unit, | |||
268 | char *buf, | |||
269 | unsigned int *bytes_read_ptr) | |||
270 | { | |||
271 | bfd_uint64_t offset; | |||
272 | struct dwarf2_debug *stash = unit->stash; | |||
273 | ||||
274 | if (unit->offset_size == 4) | |||
275 | offset = read_4_bytes (unit->abfd, buf); | |||
276 | else | |||
277 | offset = read_8_bytes (unit->abfd, buf); | |||
278 | *bytes_read_ptr = unit->offset_size; | |||
279 | ||||
280 | if (! stash->dwarf_str_buffer) | |||
281 | { | |||
282 | asection *msec; | |||
283 | bfd *abfd = unit->abfd; | |||
284 | ||||
285 | msec = bfd_get_section_by_name (abfd, ".debug_str"); | |||
286 | if (! msec) | |||
287 | { | |||
288 | (*_bfd_error_handler) | |||
289 | (_("Dwarf Error: Can't find .debug_str section.")("Dwarf Error: Can't find .debug_str section.")); | |||
290 | bfd_set_error (bfd_error_bad_value); | |||
291 | return NULL((void*)0); | |||
292 | } | |||
293 | ||||
294 | stash->dwarf_str_size = msec->_raw_size; | |||
295 | stash->dwarf_str_buffer = bfd_alloc (abfd, msec->_raw_size); | |||
296 | if (! stash->dwarf_abbrev_buffer) | |||
297 | return NULL((void*)0); | |||
298 | ||||
299 | if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer, | |||
300 | 0, msec->_raw_size)) | |||
301 | return NULL((void*)0); | |||
302 | } | |||
303 | ||||
304 | if (offset >= stash->dwarf_str_size) | |||
305 | { | |||
306 | (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu).")("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)." ), | |||
307 | (unsigned long) offset, stash->dwarf_str_size); | |||
308 | bfd_set_error (bfd_error_bad_value); | |||
309 | return NULL((void*)0); | |||
310 | } | |||
311 | ||||
312 | buf = stash->dwarf_str_buffer + offset; | |||
313 | if (*buf == '\0') | |||
314 | return NULL((void*)0); | |||
315 | return buf; | |||
316 | } | |||
317 | ||||
318 | static unsigned int | |||
319 | read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), | |||
320 | char *buf, | |||
321 | unsigned int *bytes_read_ptr) | |||
322 | { | |||
323 | unsigned int result; | |||
324 | unsigned int num_read; | |||
325 | int shift; | |||
326 | unsigned char byte; | |||
327 | ||||
328 | result = 0; | |||
329 | shift = 0; | |||
330 | num_read = 0; | |||
331 | ||||
332 | do | |||
333 | { | |||
334 | byte = bfd_get_8 (abfd, buf)(*(unsigned char *) (buf) & 0xff); | |||
335 | buf ++; | |||
336 | num_read ++; | |||
337 | result |= ((byte & 0x7f) << shift); | |||
338 | shift += 7; | |||
339 | } | |||
340 | while (byte & 0x80); | |||
341 | ||||
342 | * bytes_read_ptr = num_read; | |||
343 | ||||
344 | return result; | |||
345 | } | |||
346 | ||||
347 | static int | |||
348 | read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), | |||
349 | char *buf, | |||
350 | unsigned int * bytes_read_ptr) | |||
351 | { | |||
352 | int result; | |||
353 | int shift; | |||
354 | int num_read; | |||
355 | unsigned char byte; | |||
356 | ||||
357 | result = 0; | |||
358 | shift = 0; | |||
359 | num_read = 0; | |||
360 | ||||
361 | do | |||
362 | { | |||
363 | byte = bfd_get_8 (abfd, buf)(*(unsigned char *) (buf) & 0xff); | |||
364 | buf ++; | |||
365 | num_read ++; | |||
366 | result |= ((byte & 0x7f) << shift); | |||
367 | shift += 7; | |||
368 | } | |||
369 | while (byte & 0x80); | |||
370 | ||||
371 | if ((shift < 32) && (byte & 0x40)) | |||
372 | result |= -(1 << shift); | |||
373 | ||||
374 | * bytes_read_ptr = num_read; | |||
375 | ||||
376 | return result; | |||
377 | } | |||
378 | ||||
379 | /* END VERBATIM */ | |||
380 | ||||
381 | static bfd_uint64_t | |||
382 | read_address (struct comp_unit *unit, char *buf) | |||
383 | { | |||
384 | switch (unit->addr_size) | |||
385 | { | |||
386 | case 8: | |||
387 | return bfd_get_64 (unit->abfd, buf)((*((unit->abfd)->xvec->bfd_getx64)) (buf)); | |||
388 | case 4: | |||
389 | return bfd_get_32 (unit->abfd, buf)((*((unit->abfd)->xvec->bfd_getx32)) (buf)); | |||
390 | case 2: | |||
391 | return bfd_get_16 (unit->abfd, buf)((*((unit->abfd)->xvec->bfd_getx16)) (buf)); | |||
392 | default: | |||
393 | abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/dwarf2.c", 393 , __PRETTY_FUNCTION__); | |||
394 | } | |||
395 | } | |||
396 | ||||
397 | /* Lookup an abbrev_info structure in the abbrev hash table. */ | |||
398 | ||||
399 | static struct abbrev_info * | |||
400 | lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs) | |||
401 | { | |||
402 | unsigned int hash_number; | |||
403 | struct abbrev_info *abbrev; | |||
404 | ||||
405 | hash_number = number % ABBREV_HASH_SIZE121; | |||
406 | abbrev = abbrevs[hash_number]; | |||
407 | ||||
408 | while (abbrev) | |||
409 | { | |||
410 | if (abbrev->number == number) | |||
411 | return abbrev; | |||
412 | else | |||
413 | abbrev = abbrev->next; | |||
414 | } | |||
415 | ||||
416 | return NULL((void*)0); | |||
417 | } | |||
418 | ||||
419 | /* In DWARF version 2, the description of the debugging information is | |||
420 | stored in a separate .debug_abbrev section. Before we read any | |||
421 | dies from a section we read in all abbreviations and install them | |||
422 | in a hash table. */ | |||
423 | ||||
424 | static struct abbrev_info** | |||
425 | read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash) | |||
426 | { | |||
427 | struct abbrev_info **abbrevs; | |||
428 | char *abbrev_ptr; | |||
429 | struct abbrev_info *cur_abbrev; | |||
430 | unsigned int abbrev_number, bytes_read, abbrev_name; | |||
431 | unsigned int abbrev_form, hash_number; | |||
432 | bfd_size_type amt; | |||
433 | ||||
434 | if (! stash->dwarf_abbrev_buffer) | |||
435 | { | |||
436 | asection *msec; | |||
437 | ||||
438 | msec = bfd_get_section_by_name (abfd, ".debug_abbrev"); | |||
439 | if (! msec) | |||
440 | { | |||
441 | (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section.")("Dwarf Error: Can't find .debug_abbrev section.")); | |||
442 | bfd_set_error (bfd_error_bad_value); | |||
443 | return 0; | |||
444 | } | |||
445 | ||||
446 | stash->dwarf_abbrev_size = msec->_raw_size; | |||
447 | stash->dwarf_abbrev_buffer | |||
448 | = bfd_simple_get_relocated_section_contents (abfd, msec, NULL((void*)0), | |||
449 | stash->syms); | |||
450 | if (! stash->dwarf_abbrev_buffer) | |||
451 | return 0; | |||
452 | } | |||
453 | ||||
454 | if (offset >= stash->dwarf_abbrev_size) | |||
455 | { | |||
456 | (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu).")("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)." ), | |||
457 | (unsigned long) offset, stash->dwarf_abbrev_size); | |||
458 | bfd_set_error (bfd_error_bad_value); | |||
459 | return 0; | |||
460 | } | |||
461 | ||||
462 | amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE121; | |||
463 | abbrevs = bfd_zalloc (abfd, amt); | |||
464 | ||||
465 | abbrev_ptr = stash->dwarf_abbrev_buffer + offset; | |||
466 | abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); | |||
467 | abbrev_ptr += bytes_read; | |||
468 | ||||
469 | /* Loop until we reach an abbrev number of 0. */ | |||
470 | while (abbrev_number) | |||
471 | { | |||
472 | amt = sizeof (struct abbrev_info); | |||
473 | cur_abbrev = bfd_zalloc (abfd, amt); | |||
474 | ||||
475 | /* Read in abbrev header. */ | |||
476 | cur_abbrev->number = abbrev_number; | |||
477 | cur_abbrev->tag = (enum dwarf_tag) | |||
478 | read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); | |||
479 | abbrev_ptr += bytes_read; | |||
480 | cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr); | |||
481 | abbrev_ptr += 1; | |||
482 | ||||
483 | /* Now read in declarations. */ | |||
484 | abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); | |||
485 | abbrev_ptr += bytes_read; | |||
486 | abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); | |||
487 | abbrev_ptr += bytes_read; | |||
488 | ||||
489 | while (abbrev_name) | |||
490 | { | |||
491 | if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK4) == 0) | |||
492 | { | |||
493 | amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK4; | |||
494 | amt *= sizeof (struct attr_abbrev); | |||
495 | cur_abbrev->attrs = bfd_realloc (cur_abbrev->attrs, amt); | |||
496 | if (! cur_abbrev->attrs) | |||
497 | return 0; | |||
498 | } | |||
499 | ||||
500 | cur_abbrev->attrs[cur_abbrev->num_attrs].name | |||
501 | = (enum dwarf_attribute) abbrev_name; | |||
502 | cur_abbrev->attrs[cur_abbrev->num_attrs++].form | |||
503 | = (enum dwarf_form) abbrev_form; | |||
504 | abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); | |||
505 | abbrev_ptr += bytes_read; | |||
506 | abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); | |||
507 | abbrev_ptr += bytes_read; | |||
508 | } | |||
509 | ||||
510 | hash_number = abbrev_number % ABBREV_HASH_SIZE121; | |||
511 | cur_abbrev->next = abbrevs[hash_number]; | |||
512 | abbrevs[hash_number] = cur_abbrev; | |||
513 | ||||
514 | /* Get next abbreviation. | |||
515 | Under Irix6 the abbreviations for a compilation unit are not | |||
516 | always properly terminated with an abbrev number of 0. | |||
517 | Exit loop if we encounter an abbreviation which we have | |||
518 | already read (which means we are about to read the abbreviations | |||
519 | for the next compile unit) or if the end of the abbreviation | |||
520 | table is reached. */ | |||
521 | if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer) | |||
522 | >= stash->dwarf_abbrev_size) | |||
523 | break; | |||
524 | abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); | |||
525 | abbrev_ptr += bytes_read; | |||
526 | if (lookup_abbrev (abbrev_number,abbrevs) != NULL((void*)0)) | |||
527 | break; | |||
528 | } | |||
529 | ||||
530 | return abbrevs; | |||
531 | } | |||
532 | ||||
533 | /* Read an attribute value described by an attribute form. */ | |||
534 | ||||
535 | static char * | |||
536 | read_attribute_value (struct attribute *attr, | |||
537 | unsigned form, | |||
538 | struct comp_unit *unit, | |||
539 | char *info_ptr) | |||
540 | { | |||
541 | bfd *abfd = unit->abfd; | |||
542 | unsigned int bytes_read; | |||
543 | struct dwarf_block *blk; | |||
544 | bfd_size_type amt; | |||
545 | ||||
546 | attr->form = (enum dwarf_form) form; | |||
547 | ||||
548 | switch (form) | |||
549 | { | |||
550 | case DW_FORM_addr: | |||
551 | /* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size. */ | |||
552 | case DW_FORM_ref_addr: | |||
553 | attr->u.val = read_address (unit, info_ptr); | |||
554 | info_ptr += unit->addr_size; | |||
555 | break; | |||
556 | case DW_FORM_block2: | |||
557 | amt = sizeof (struct dwarf_block); | |||
558 | blk = bfd_alloc (abfd, amt); | |||
559 | blk->size = read_2_bytes (abfd, info_ptr); | |||
560 | info_ptr += 2; | |||
561 | blk->data = read_n_bytes (abfd, info_ptr, blk->size); | |||
562 | info_ptr += blk->size; | |||
563 | attr->u.blk = blk; | |||
564 | break; | |||
565 | case DW_FORM_block4: | |||
566 | amt = sizeof (struct dwarf_block); | |||
567 | blk = bfd_alloc (abfd, amt); | |||
568 | blk->size = read_4_bytes (abfd, info_ptr); | |||
569 | info_ptr += 4; | |||
570 | blk->data = read_n_bytes (abfd, info_ptr, blk->size); | |||
571 | info_ptr += blk->size; | |||
572 | attr->u.blk = blk; | |||
573 | break; | |||
574 | case DW_FORM_data2: | |||
575 | attr->u.val = read_2_bytes (abfd, info_ptr); | |||
576 | info_ptr += 2; | |||
577 | break; | |||
578 | case DW_FORM_data4: | |||
579 | attr->u.val = read_4_bytes (abfd, info_ptr); | |||
580 | info_ptr += 4; | |||
581 | break; | |||
582 | case DW_FORM_data8: | |||
583 | attr->u.val = read_8_bytes (abfd, info_ptr); | |||
584 | info_ptr += 8; | |||
585 | break; | |||
586 | case DW_FORM_string: | |||
587 | attr->u.str = read_string (abfd, info_ptr, &bytes_read); | |||
588 | info_ptr += bytes_read; | |||
589 | break; | |||
590 | case DW_FORM_strp: | |||
591 | attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read); | |||
592 | info_ptr += bytes_read; | |||
593 | break; | |||
594 | case DW_FORM_block: | |||
595 | amt = sizeof (struct dwarf_block); | |||
596 | blk = bfd_alloc (abfd, amt); | |||
597 | blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); | |||
598 | info_ptr += bytes_read; | |||
599 | blk->data = read_n_bytes (abfd, info_ptr, blk->size); | |||
600 | info_ptr += blk->size; | |||
601 | attr->u.blk = blk; | |||
602 | break; | |||
603 | case DW_FORM_block1: | |||
604 | amt = sizeof (struct dwarf_block); | |||
605 | blk = bfd_alloc (abfd, amt); | |||
606 | blk->size = read_1_byte (abfd, info_ptr); | |||
607 | info_ptr += 1; | |||
608 | blk->data = read_n_bytes (abfd, info_ptr, blk->size); | |||
609 | info_ptr += blk->size; | |||
610 | attr->u.blk = blk; | |||
611 | break; | |||
612 | case DW_FORM_data1: | |||
613 | attr->u.val = read_1_byte (abfd, info_ptr); | |||
614 | info_ptr += 1; | |||
615 | break; | |||
616 | case DW_FORM_flag: | |||
617 | attr->u.val = read_1_byte (abfd, info_ptr); | |||
618 | info_ptr += 1; | |||
619 | break; | |||
620 | case DW_FORM_sdata: | |||
621 | attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read); | |||
622 | info_ptr += bytes_read; | |||
623 | break; | |||
624 | case DW_FORM_udata: | |||
625 | attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); | |||
626 | info_ptr += bytes_read; | |||
627 | break; | |||
628 | case DW_FORM_ref1: | |||
629 | attr->u.val = read_1_byte (abfd, info_ptr); | |||
630 | info_ptr += 1; | |||
631 | break; | |||
632 | case DW_FORM_ref2: | |||
633 | attr->u.val = read_2_bytes (abfd, info_ptr); | |||
634 | info_ptr += 2; | |||
635 | break; | |||
636 | case DW_FORM_ref4: | |||
637 | attr->u.val = read_4_bytes (abfd, info_ptr); | |||
638 | info_ptr += 4; | |||
639 | break; | |||
640 | case DW_FORM_ref8: | |||
641 | attr->u.val = read_8_bytes (abfd, info_ptr); | |||
642 | info_ptr += 8; | |||
643 | break; | |||
644 | case DW_FORM_ref_udata: | |||
645 | attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); | |||
646 | info_ptr += bytes_read; | |||
647 | break; | |||
648 | case DW_FORM_indirect: | |||
649 | form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); | |||
650 | info_ptr += bytes_read; | |||
651 | info_ptr = read_attribute_value (attr, form, unit, info_ptr); | |||
652 | break; | |||
653 | default: | |||
654 | (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u.")("Dwarf Error: Invalid or unhandled FORM value: %u."), | |||
655 | form); | |||
656 | bfd_set_error (bfd_error_bad_value); | |||
657 | } | |||
658 | return info_ptr; | |||
659 | } | |||
660 | ||||
661 | /* Read an attribute described by an abbreviated attribute. */ | |||
662 | ||||
663 | static char * | |||
664 | read_attribute (struct attribute *attr, | |||
665 | struct attr_abbrev *abbrev, | |||
666 | struct comp_unit *unit, | |||
667 | char *info_ptr) | |||
668 | { | |||
669 | attr->name = abbrev->name; | |||
670 | info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr); | |||
671 | return info_ptr; | |||
672 | } | |||
673 | ||||
674 | /* Source line information table routines. */ | |||
675 | ||||
676 | #define FILE_ALLOC_CHUNK5 5 | |||
677 | #define DIR_ALLOC_CHUNK5 5 | |||
678 | ||||
679 | struct line_info | |||
680 | { | |||
681 | struct line_info* prev_line; | |||
682 | bfd_vma address; | |||
683 | char* filename; | |||
684 | unsigned int line; | |||
685 | unsigned int column; | |||
686 | int end_sequence; /* End of (sequential) code sequence. */ | |||
687 | }; | |||
688 | ||||
689 | struct fileinfo | |||
690 | { | |||
691 | char *name; | |||
692 | unsigned int dir; | |||
693 | unsigned int time; | |||
694 | unsigned int size; | |||
695 | }; | |||
696 | ||||
697 | struct line_info_table | |||
698 | { | |||
699 | bfd* abfd; | |||
700 | unsigned int num_files; | |||
701 | unsigned int num_dirs; | |||
702 | char* comp_dir; | |||
703 | char** dirs; | |||
704 | struct fileinfo* files; | |||
705 | struct line_info* last_line; /* largest VMA */ | |||
706 | struct line_info* lcl_head; /* local head; used in 'add_line_info' */ | |||
707 | }; | |||
708 | ||||
709 | struct funcinfo | |||
710 | { | |||
711 | struct funcinfo *prev_func; | |||
712 | char* name; | |||
713 | bfd_vma low; | |||
714 | bfd_vma high; | |||
715 | }; | |||
716 | ||||
717 | /* Adds a new entry to the line_info list in the line_info_table, ensuring | |||
718 | that the list is sorted. Note that the line_info list is sorted from | |||
719 | highest to lowest VMA (with possible duplicates); that is, | |||
720 | line_info->prev_line always accesses an equal or smaller VMA. */ | |||
721 | ||||
722 | static void | |||
723 | add_line_info (struct line_info_table *table, | |||
724 | bfd_vma address, | |||
725 | char *filename, | |||
726 | unsigned int line, | |||
727 | unsigned int column, | |||
728 | int end_sequence) | |||
729 | { | |||
730 | bfd_size_type amt = sizeof (struct line_info); | |||
731 | struct line_info* info = bfd_alloc (table->abfd, amt); | |||
732 | ||||
733 | /* Find the correct location for 'info'. Normally we will receive | |||
734 | new line_info data 1) in order and 2) with increasing VMAs. | |||
735 | However some compilers break the rules (cf. decode_line_info) and | |||
736 | so we include some heuristics for quickly finding the correct | |||
737 | location for 'info'. In particular, these heuristics optimize for | |||
738 | the common case in which the VMA sequence that we receive is a | |||
739 | list of locally sorted VMAs such as | |||
740 | p...z a...j (where a < j < p < z) | |||
741 | ||||
742 | Note: table->lcl_head is used to head an *actual* or *possible* | |||
743 | sequence within the list (such as a...j) that is not directly | |||
744 | headed by table->last_line | |||
745 | ||||
746 | Note: we may receive duplicate entries from 'decode_line_info'. */ | |||
747 | ||||
748 | while (1) | |||
749 | if (!table->last_line | |||
750 | || address >= table->last_line->address) | |||
751 | { | |||
752 | /* Normal case: add 'info' to the beginning of the list */ | |||
753 | info->prev_line = table->last_line; | |||
754 | table->last_line = info; | |||
755 | ||||
756 | /* lcl_head: initialize to head a *possible* sequence at the end. */ | |||
757 | if (!table->lcl_head) | |||
758 | table->lcl_head = info; | |||
759 | break; | |||
760 | } | |||
761 | else if (!table->lcl_head->prev_line | |||
762 | && table->lcl_head->address > address) | |||
763 | { | |||
764 | /* Abnormal but easy: lcl_head is 1) at the *end* of the line | |||
765 | list and 2) the head of 'info'. */ | |||
766 | info->prev_line = NULL((void*)0); | |||
767 | table->lcl_head->prev_line = info; | |||
768 | break; | |||
769 | } | |||
770 | else if (table->lcl_head->prev_line | |||
771 | && table->lcl_head->address > address | |||
772 | && address >= table->lcl_head->prev_line->address) | |||
773 | { | |||
774 | /* Abnormal but easy: lcl_head is 1) in the *middle* of the line | |||
775 | list and 2) the head of 'info'. */ | |||
776 | info->prev_line = table->lcl_head->prev_line; | |||
777 | table->lcl_head->prev_line = info; | |||
778 | break; | |||
779 | } | |||
780 | else | |||
781 | { | |||
782 | /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid | |||
783 | heads for 'info'. Reset 'lcl_head' and repeat. */ | |||
784 | struct line_info* li2 = table->last_line; /* always non-NULL */ | |||
785 | struct line_info* li1 = li2->prev_line; | |||
786 | ||||
787 | while (li1) | |||
788 | { | |||
789 | if (li2->address > address && address >= li1->address) | |||
790 | break; | |||
791 | ||||
792 | li2 = li1; /* always non-NULL */ | |||
793 | li1 = li1->prev_line; | |||
794 | } | |||
795 | table->lcl_head = li2; | |||
796 | } | |||
797 | ||||
798 | /* Set member data of 'info'. */ | |||
799 | info->address = address; | |||
800 | info->line = line; | |||
801 | info->column = column; | |||
802 | info->end_sequence = end_sequence; | |||
803 | ||||
804 | if (filename && filename[0]) | |||
805 | { | |||
806 | info->filename = bfd_alloc (table->abfd, strlen (filename) + 1); | |||
807 | if (info->filename) | |||
808 | strcpy (info->filename, filename); | |||
809 | } | |||
810 | else | |||
811 | info->filename = NULL((void*)0); | |||
812 | } | |||
813 | ||||
814 | /* Extract a fully qualified filename from a line info table. | |||
815 | The returned string has been malloc'ed and it is the caller's | |||
816 | responsibility to free it. */ | |||
817 | ||||
818 | static char * | |||
819 | concat_filename (struct line_info_table *table, unsigned int file) | |||
820 | { | |||
821 | char* filename; | |||
822 | ||||
823 | if (file - 1 >= table->num_files) | |||
824 | { | |||
825 | (*_bfd_error_handler) | |||
826 | (_("Dwarf Error: mangled line number section (bad file number).")("Dwarf Error: mangled line number section (bad file number)." )); | |||
827 | return strdup ("<unknown>"); | |||
828 | } | |||
829 | ||||
830 | filename = table->files[file - 1].name; | |||
831 | ||||
832 | if (! IS_ABSOLUTE_PATH (filename)((((filename)[0]) == '/'))) | |||
833 | { | |||
834 | char* dirname = (table->files[file - 1].dir | |||
835 | ? table->dirs[table->files[file - 1].dir - 1] | |||
836 | : table->comp_dir); | |||
837 | ||||
838 | /* Not all tools set DW_AT_comp_dir, so dirname may be unknown. | |||
839 | The best we can do is return the filename part. */ | |||
840 | if (dirname != NULL((void*)0)) | |||
841 | { | |||
842 | unsigned int len = strlen (dirname) + strlen (filename) + 2; | |||
843 | char * name; | |||
844 | ||||
845 | name = bfd_malloc (len); | |||
846 | if (name) | |||
847 | sprintf (name, "%s/%s", dirname, filename); | |||
848 | return name; | |||
849 | } | |||
850 | } | |||
851 | ||||
852 | return strdup (filename); | |||
853 | } | |||
854 | ||||
855 | static void | |||
856 | arange_add (struct comp_unit *unit, bfd_vma low_pc, bfd_vma high_pc) | |||
857 | { | |||
858 | struct arange *arange; | |||
859 | ||||
860 | /* First see if we can cheaply extend an existing range. */ | |||
861 | arange = &unit->arange; | |||
862 | ||||
863 | do | |||
864 | { | |||
865 | if (low_pc == arange->high) | |||
866 | { | |||
867 | arange->high = high_pc; | |||
868 | return; | |||
869 | } | |||
870 | if (high_pc == arange->low) | |||
871 | { | |||
872 | arange->low = low_pc; | |||
873 | return; | |||
874 | } | |||
875 | arange = arange->next; | |||
876 | } | |||
877 | while (arange); | |||
878 | ||||
879 | if (unit->arange.high == 0) | |||
880 | { | |||
881 | /* This is the first address range: store it in unit->arange. */ | |||
882 | unit->arange.next = 0; | |||
883 | unit->arange.low = low_pc; | |||
884 | unit->arange.high = high_pc; | |||
885 | return; | |||
886 | } | |||
887 | ||||
888 | /* Need to allocate a new arange and insert it into the arange list. */ | |||
889 | arange = bfd_zalloc (unit->abfd, sizeof (*arange)); | |||
890 | arange->low = low_pc; | |||
891 | arange->high = high_pc; | |||
892 | ||||
893 | arange->next = unit->arange.next; | |||
894 | unit->arange.next = arange; | |||
895 | } | |||
896 | ||||
897 | /* Decode the line number information for UNIT. */ | |||
898 | ||||
899 | static struct line_info_table* | |||
900 | decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash) | |||
901 | { | |||
902 | bfd *abfd = unit->abfd; | |||
903 | struct line_info_table* table; | |||
904 | char *line_ptr; | |||
905 | char *line_end; | |||
906 | struct line_head lh; | |||
907 | unsigned int i, bytes_read, offset_size; | |||
908 | char *cur_file, *cur_dir; | |||
909 | unsigned char op_code, extended_op, adj_opcode; | |||
910 | bfd_size_type amt; | |||
911 | ||||
912 | if (! stash->dwarf_line_buffer) | |||
913 | { | |||
914 | asection *msec; | |||
915 | ||||
916 | msec = bfd_get_section_by_name (abfd, ".debug_line"); | |||
917 | if (! msec) | |||
918 | { | |||
919 | (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section.")("Dwarf Error: Can't find .debug_line section.")); | |||
920 | bfd_set_error (bfd_error_bad_value); | |||
921 | return 0; | |||
922 | } | |||
923 | ||||
924 | stash->dwarf_line_size = msec->_raw_size; | |||
925 | stash->dwarf_line_buffer | |||
926 | = bfd_simple_get_relocated_section_contents (abfd, msec, NULL((void*)0), | |||
927 | stash->syms); | |||
928 | if (! stash->dwarf_line_buffer) | |||
929 | return 0; | |||
930 | } | |||
931 | ||||
932 | /* It is possible to get a bad value for the line_offset. Validate | |||
933 | it here so that we won't get a segfault below. */ | |||
934 | if (unit->line_offset >= stash->dwarf_line_size) | |||
935 | { | |||
936 | (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu).")("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)." ), | |||
937 | unit->line_offset, stash->dwarf_line_size); | |||
938 | bfd_set_error (bfd_error_bad_value); | |||
939 | return 0; | |||
940 | } | |||
941 | ||||
942 | amt = sizeof (struct line_info_table); | |||
943 | table = bfd_alloc (abfd, amt); | |||
944 | table->abfd = abfd; | |||
945 | table->comp_dir = unit->comp_dir; | |||
946 | ||||
947 | table->num_files = 0; | |||
948 | table->files = NULL((void*)0); | |||
949 | ||||
950 | table->num_dirs = 0; | |||
951 | table->dirs = NULL((void*)0); | |||
952 | ||||
953 | table->files = NULL((void*)0); | |||
954 | table->last_line = NULL((void*)0); | |||
955 | table->lcl_head = NULL((void*)0); | |||
956 | ||||
957 | line_ptr = stash->dwarf_line_buffer + unit->line_offset; | |||
958 | ||||
959 | /* Read in the prologue. */ | |||
960 | lh.total_length = read_4_bytes (abfd, line_ptr); | |||
961 | line_ptr += 4; | |||
962 | offset_size = 4; | |||
963 | if (lh.total_length == 0xffffffff) | |||
964 | { | |||
965 | lh.total_length = read_8_bytes (abfd, line_ptr); | |||
966 | line_ptr += 8; | |||
967 | offset_size = 8; | |||
968 | } | |||
969 | else if (lh.total_length == 0 && unit->addr_size == 8) | |||
970 | { | |||
971 | /* Handle (non-standard) 64-bit DWARF2 formats. */ | |||
972 | lh.total_length = read_4_bytes (abfd, line_ptr); | |||
973 | line_ptr += 4; | |||
974 | offset_size = 8; | |||
975 | } | |||
976 | line_end = line_ptr + lh.total_length; | |||
977 | lh.version = read_2_bytes (abfd, line_ptr); | |||
978 | line_ptr += 2; | |||
979 | if (offset_size == 4) | |||
980 | lh.prologue_length = read_4_bytes (abfd, line_ptr); | |||
981 | else | |||
982 | lh.prologue_length = read_8_bytes (abfd, line_ptr); | |||
983 | line_ptr += offset_size; | |||
984 | lh.minimum_instruction_length = read_1_byte (abfd, line_ptr); | |||
985 | line_ptr += 1; | |||
986 | lh.default_is_stmt = read_1_byte (abfd, line_ptr); | |||
987 | line_ptr += 1; | |||
988 | lh.line_base = read_1_signed_byte (abfd, line_ptr); | |||
989 | line_ptr += 1; | |||
990 | lh.line_range = read_1_byte (abfd, line_ptr); | |||
991 | line_ptr += 1; | |||
992 | lh.opcode_base = read_1_byte (abfd, line_ptr); | |||
993 | line_ptr += 1; | |||
994 | amt = lh.opcode_base * sizeof (unsigned char); | |||
995 | lh.standard_opcode_lengths = bfd_alloc (abfd, amt); | |||
996 | ||||
997 | lh.standard_opcode_lengths[0] = 1; | |||
998 | ||||
999 | for (i = 1; i < lh.opcode_base; ++i) | |||
1000 | { | |||
1001 | lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr); | |||
1002 | line_ptr += 1; | |||
1003 | } | |||
1004 | ||||
1005 | /* Read directory table. */ | |||
1006 | while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL((void*)0)) | |||
1007 | { | |||
1008 | line_ptr += bytes_read; | |||
1009 | ||||
1010 | if ((table->num_dirs % DIR_ALLOC_CHUNK5) == 0) | |||
1011 | { | |||
1012 | amt = table->num_dirs + DIR_ALLOC_CHUNK5; | |||
1013 | amt *= sizeof (char *); | |||
1014 | table->dirs = bfd_realloc (table->dirs, amt); | |||
1015 | if (! table->dirs) | |||
1016 | return 0; | |||
1017 | } | |||
1018 | ||||
1019 | table->dirs[table->num_dirs++] = cur_dir; | |||
1020 | } | |||
1021 | ||||
1022 | line_ptr += bytes_read; | |||
1023 | ||||
1024 | /* Read file name table. */ | |||
1025 | while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL((void*)0)) | |||
1026 | { | |||
1027 | line_ptr += bytes_read; | |||
1028 | ||||
1029 | if ((table->num_files % FILE_ALLOC_CHUNK5) == 0) | |||
1030 | { | |||
1031 | amt = table->num_files + FILE_ALLOC_CHUNK5; | |||
1032 | amt *= sizeof (struct fileinfo); | |||
1033 | table->files = bfd_realloc (table->files, amt); | |||
1034 | if (! table->files) | |||
1035 | return 0; | |||
1036 | } | |||
1037 | ||||
1038 | table->files[table->num_files].name = cur_file; | |||
1039 | table->files[table->num_files].dir = | |||
1040 | read_unsigned_leb128 (abfd, line_ptr, &bytes_read); | |||
1041 | line_ptr += bytes_read; | |||
1042 | table->files[table->num_files].time = | |||
1043 | read_unsigned_leb128 (abfd, line_ptr, &bytes_read); | |||
1044 | line_ptr += bytes_read; | |||
1045 | table->files[table->num_files].size = | |||
1046 | read_unsigned_leb128 (abfd, line_ptr, &bytes_read); | |||
1047 | line_ptr += bytes_read; | |||
1048 | table->num_files++; | |||
1049 | } | |||
1050 | ||||
1051 | line_ptr += bytes_read; | |||
1052 | ||||
1053 | /* Read the statement sequences until there's nothing left. */ | |||
1054 | while (line_ptr < line_end) | |||
1055 | { | |||
1056 | /* State machine registers. */ | |||
1057 | bfd_vma address = 0; | |||
1058 | char * filename = table->num_files ? concat_filename (table, 1) : NULL((void*)0); | |||
1059 | unsigned int line = 1; | |||
1060 | unsigned int column = 0; | |||
1061 | int is_stmt = lh.default_is_stmt; | |||
1062 | int basic_block = 0; | |||
1063 | int end_sequence = 0; | |||
1064 | /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some | |||
1065 | compilers generate address sequences that are wildly out of | |||
1066 | order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler | |||
1067 | for ia64-Linux). Thus, to determine the low and high | |||
1068 | address, we must compare on every DW_LNS_copy, etc. */ | |||
1069 | bfd_vma low_pc = 0; | |||
1070 | bfd_vma high_pc = 0; | |||
1071 | ||||
1072 | /* Decode the table. */ | |||
1073 | while (! end_sequence) | |||
1074 | { | |||
1075 | op_code = read_1_byte (abfd, line_ptr); | |||
1076 | line_ptr += 1; | |||
1077 | ||||
1078 | if (op_code >= lh.opcode_base) | |||
1079 | { | |||
1080 | /* Special operand. */ | |||
1081 | adj_opcode = op_code - lh.opcode_base; | |||
1082 | address += (adj_opcode / lh.line_range) | |||
1083 | * lh.minimum_instruction_length; | |||
1084 | line += lh.line_base + (adj_opcode % lh.line_range); | |||
1085 | /* Append row to matrix using current values. */ | |||
1086 | add_line_info (table, address, filename, line, column, 0); | |||
1087 | basic_block = 1; | |||
1088 | if (low_pc == 0 || address < low_pc) | |||
1089 | low_pc = address; | |||
1090 | if (address > high_pc) | |||
1091 | high_pc = address; | |||
1092 | } | |||
1093 | else switch (op_code) | |||
1094 | { | |||
1095 | case DW_LNS_extended_op: | |||
1096 | /* Ignore length. */ | |||
1097 | line_ptr += 1; | |||
1098 | extended_op = read_1_byte (abfd, line_ptr); | |||
1099 | line_ptr += 1; | |||
1100 | ||||
1101 | switch (extended_op) | |||
1102 | { | |||
1103 | case DW_LNE_end_sequence: | |||
1104 | end_sequence = 1; | |||
1105 | add_line_info (table, address, filename, line, column, | |||
1106 | end_sequence); | |||
1107 | if (low_pc == 0 || address < low_pc) | |||
1108 | low_pc = address; | |||
1109 | if (address > high_pc) | |||
1110 | high_pc = address; | |||
1111 | arange_add (unit, low_pc, high_pc); | |||
1112 | break; | |||
1113 | case DW_LNE_set_address: | |||
1114 | address = read_address (unit, line_ptr); | |||
1115 | line_ptr += unit->addr_size; | |||
1116 | break; | |||
1117 | case DW_LNE_define_file: | |||
1118 | cur_file = read_string (abfd, line_ptr, &bytes_read); | |||
1119 | line_ptr += bytes_read; | |||
1120 | if ((table->num_files % FILE_ALLOC_CHUNK5) == 0) | |||
1121 | { | |||
1122 | amt = table->num_files + FILE_ALLOC_CHUNK5; | |||
1123 | amt *= sizeof (struct fileinfo); | |||
1124 | table->files = bfd_realloc (table->files, amt); | |||
1125 | if (! table->files) | |||
1126 | return 0; | |||
1127 | } | |||
1128 | table->files[table->num_files].name = cur_file; | |||
1129 | table->files[table->num_files].dir = | |||
1130 | read_unsigned_leb128 (abfd, line_ptr, &bytes_read); | |||
1131 | line_ptr += bytes_read; | |||
1132 | table->files[table->num_files].time = | |||
1133 | read_unsigned_leb128 (abfd, line_ptr, &bytes_read); | |||
1134 | line_ptr += bytes_read; | |||
1135 | table->files[table->num_files].size = | |||
1136 | read_unsigned_leb128 (abfd, line_ptr, &bytes_read); | |||
1137 | line_ptr += bytes_read; | |||
1138 | table->num_files++; | |||
1139 | break; | |||
1140 | default: | |||
1141 | (*_bfd_error_handler) (_("Dwarf Error: mangled line number section.")("Dwarf Error: mangled line number section.")); | |||
1142 | bfd_set_error (bfd_error_bad_value); | |||
1143 | return 0; | |||
1144 | } | |||
1145 | break; | |||
1146 | case DW_LNS_copy: | |||
1147 | add_line_info (table, address, filename, line, column, 0); | |||
1148 | basic_block = 0; | |||
1149 | if (low_pc == 0 || address < low_pc) | |||
1150 | low_pc = address; | |||
1151 | if (address > high_pc) | |||
1152 | high_pc = address; | |||
1153 | break; | |||
1154 | case DW_LNS_advance_pc: | |||
1155 | address += lh.minimum_instruction_length | |||
1156 | * read_unsigned_leb128 (abfd, line_ptr, &bytes_read); | |||
1157 | line_ptr += bytes_read; | |||
1158 | break; | |||
1159 | case DW_LNS_advance_line: | |||
1160 | line += read_signed_leb128 (abfd, line_ptr, &bytes_read); | |||
1161 | line_ptr += bytes_read; | |||
1162 | break; | |||
1163 | case DW_LNS_set_file: | |||
1164 | { | |||
1165 | unsigned int file; | |||
1166 | ||||
1167 | /* The file and directory tables are 0 | |||
1168 | based, the references are 1 based. */ | |||
1169 | file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); | |||
1170 | line_ptr += bytes_read; | |||
1171 | if (filename) | |||
1172 | free (filename); | |||
1173 | filename = concat_filename (table, file); | |||
1174 | break; | |||
1175 | } | |||
1176 | case DW_LNS_set_column: | |||
1177 | column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); | |||
1178 | line_ptr += bytes_read; | |||
1179 | break; | |||
1180 | case DW_LNS_negate_stmt: | |||
1181 | is_stmt = (!is_stmt); | |||
1182 | break; | |||
1183 | case DW_LNS_set_basic_block: | |||
1184 | basic_block = 1; | |||
1185 | break; | |||
1186 | case DW_LNS_const_add_pc: | |||
1187 | address += lh.minimum_instruction_length | |||
1188 | * ((255 - lh.opcode_base) / lh.line_range); | |||
1189 | break; | |||
1190 | case DW_LNS_fixed_advance_pc: | |||
1191 | address += read_2_bytes (abfd, line_ptr); | |||
1192 | line_ptr += 2; | |||
1193 | break; | |||
1194 | default: | |||
1195 | { | |||
1196 | int i; | |||
1197 | ||||
1198 | /* Unknown standard opcode, ignore it. */ | |||
1199 | for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++) | |||
1200 | { | |||
1201 | (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read); | |||
1202 | line_ptr += bytes_read; | |||
1203 | } | |||
1204 | } | |||
1205 | } | |||
1206 | } | |||
1207 | ||||
1208 | if (filename) | |||
1209 | free (filename); | |||
1210 | } | |||
1211 | ||||
1212 | return table; | |||
1213 | } | |||
1214 | ||||
1215 | /* If ADDR is within TABLE set the output parameters and return TRUE, | |||
1216 | otherwise return FALSE. The output parameters, FILENAME_PTR and | |||
1217 | LINENUMBER_PTR, are pointers to the objects to be filled in. */ | |||
1218 | ||||
1219 | static bfd_boolean | |||
1220 | lookup_address_in_line_info_table (struct line_info_table *table, | |||
1221 | bfd_vma addr, | |||
1222 | struct funcinfo *function, | |||
1223 | const char **filename_ptr, | |||
1224 | unsigned int *linenumber_ptr) | |||
1225 | { | |||
1226 | /* Note: table->last_line should be a descendingly sorted list. */ | |||
1227 | struct line_info* next_line = table->last_line; | |||
1228 | struct line_info* each_line = NULL((void*)0); | |||
1229 | *filename_ptr = NULL((void*)0); | |||
1230 | ||||
1231 | if (!next_line) | |||
1232 | return FALSE0; | |||
1233 | ||||
1234 | each_line = next_line->prev_line; | |||
1235 | ||||
1236 | /* Check for large addresses */ | |||
1237 | if (addr > next_line->address) | |||
1238 | each_line = NULL((void*)0); /* ensure we skip over the normal case */ | |||
1239 | ||||
1240 | /* Normal case: search the list; save */ | |||
1241 | while (each_line && next_line) | |||
1242 | { | |||
1243 | /* If we have an address match, save this info. This allows us | |||
1244 | to return as good as results as possible for strange debugging | |||
1245 | info. */ | |||
1246 | bfd_boolean addr_match = FALSE0; | |||
1247 | if (each_line->address <= addr && addr <= next_line->address) | |||
1248 | { | |||
1249 | addr_match = TRUE1; | |||
1250 | ||||
1251 | /* If this line appears to span functions, and addr is in the | |||
1252 | later function, return the first line of that function instead | |||
1253 | of the last line of the earlier one. This check is for GCC | |||
1254 | 2.95, which emits the first line number for a function late. */ | |||
1255 | if (function != NULL((void*)0) | |||
1256 | && each_line->address < function->low | |||
1257 | && next_line->address > function->low) | |||
1258 | { | |||
1259 | *filename_ptr = next_line->filename; | |||
1260 | *linenumber_ptr = next_line->line; | |||
1261 | } | |||
1262 | else | |||
1263 | { | |||
1264 | *filename_ptr = each_line->filename; | |||
1265 | *linenumber_ptr = each_line->line; | |||
1266 | } | |||
1267 | } | |||
1268 | ||||
1269 | if (addr_match && !each_line->end_sequence) | |||
1270 | return TRUE1; /* we have definitely found what we want */ | |||
1271 | ||||
1272 | next_line = each_line; | |||
1273 | each_line = each_line->prev_line; | |||
1274 | } | |||
1275 | ||||
1276 | /* At this point each_line is NULL but next_line is not. If we found | |||
1277 | a candidate end-of-sequence point in the loop above, we can return | |||
1278 | that (compatibility with a bug in the Intel compiler); otherwise, | |||
1279 | assuming that we found the containing function for this address in | |||
1280 | this compilation unit, return the first line we have a number for | |||
1281 | (compatibility with GCC 2.95). */ | |||
1282 | if (*filename_ptr == NULL((void*)0) && function != NULL((void*)0)) | |||
1283 | { | |||
1284 | *filename_ptr = next_line->filename; | |||
1285 | *linenumber_ptr = next_line->line; | |||
1286 | return TRUE1; | |||
1287 | } | |||
1288 | ||||
1289 | return FALSE0; | |||
1290 | } | |||
1291 | ||||
1292 | /* Function table functions. */ | |||
1293 | ||||
1294 | /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE. */ | |||
1295 | ||||
1296 | static bfd_boolean | |||
1297 | lookup_address_in_function_table (struct funcinfo *table, | |||
1298 | bfd_vma addr, | |||
1299 | struct funcinfo **function_ptr, | |||
1300 | const char **functionname_ptr) | |||
1301 | { | |||
1302 | struct funcinfo* each_func; | |||
1303 | ||||
1304 | for (each_func = table; | |||
1305 | each_func; | |||
1306 | each_func = each_func->prev_func) | |||
1307 | { | |||
1308 | if (addr >= each_func->low && addr < each_func->high) | |||
1309 | { | |||
1310 | *functionname_ptr = each_func->name; | |||
1311 | *function_ptr = each_func; | |||
1312 | return TRUE1; | |||
1313 | } | |||
1314 | } | |||
1315 | ||||
1316 | return FALSE0; | |||
1317 | } | |||
1318 | ||||
1319 | /* DWARF2 Compilation unit functions. */ | |||
1320 | ||||
1321 | /* Scan over each die in a comp. unit looking for functions to add | |||
1322 | to the function table. */ | |||
1323 | ||||
1324 | static bfd_boolean | |||
1325 | scan_unit_for_functions (struct comp_unit *unit) | |||
1326 | { | |||
1327 | bfd *abfd = unit->abfd; | |||
1328 | char *info_ptr = unit->first_child_die_ptr; | |||
1329 | int nesting_level = 1; | |||
1330 | ||||
1331 | while (nesting_level) | |||
1332 | { | |||
1333 | unsigned int abbrev_number, bytes_read, i; | |||
1334 | struct abbrev_info *abbrev; | |||
1335 | struct attribute attr; | |||
1336 | struct funcinfo *func; | |||
1337 | char* name = 0; | |||
1338 | ||||
1339 | abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); | |||
1340 | info_ptr += bytes_read; | |||
1341 | ||||
1342 | if (! abbrev_number) | |||
1343 | { | |||
1344 | nesting_level--; | |||
1345 | continue; | |||
1346 | } | |||
1347 | ||||
1348 | abbrev = lookup_abbrev (abbrev_number,unit->abbrevs); | |||
1349 | if (! abbrev) | |||
1350 | { | |||
1351 | (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u.")("Dwarf Error: Could not find abbrev number %u."), | |||
1352 | abbrev_number); | |||
1353 | bfd_set_error (bfd_error_bad_value); | |||
1354 | return FALSE0; | |||
1355 | } | |||
1356 | ||||
1357 | if (abbrev->tag == DW_TAG_subprogram) | |||
1358 | { | |||
1359 | bfd_size_type amt = sizeof (struct funcinfo); | |||
1360 | func = bfd_zalloc (abfd, amt); | |||
1361 | func->prev_func = unit->function_table; | |||
1362 | unit->function_table = func; | |||
1363 | } | |||
1364 | else | |||
1365 | func = NULL((void*)0); | |||
1366 | ||||
1367 | for (i = 0; i < abbrev->num_attrs; ++i) | |||
1368 | { | |||
1369 | info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr); | |||
1370 | ||||
1371 | if (func) | |||
1372 | { | |||
1373 | switch (attr.name) | |||
1374 | { | |||
1375 | case DW_AT_name: | |||
1376 | ||||
1377 | name = attr.u.str; | |||
1378 | ||||
1379 | /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */ | |||
1380 | if (func->name == NULL((void*)0)) | |||
1381 | func->name = attr.u.str; | |||
1382 | break; | |||
1383 | ||||
1384 | case DW_AT_MIPS_linkage_name: | |||
1385 | func->name = attr.u.str; | |||
1386 | break; | |||
1387 | ||||
1388 | case DW_AT_low_pc: | |||
1389 | func->low = attr.u.val; | |||
1390 | break; | |||
1391 | ||||
1392 | case DW_AT_high_pc: | |||
1393 | func->high = attr.u.val; | |||
1394 | break; | |||
1395 | ||||
1396 | default: | |||
1397 | break; | |||
1398 | } | |||
1399 | } | |||
1400 | else | |||
1401 | { | |||
1402 | switch (attr.name) | |||
1403 | { | |||
1404 | case DW_AT_name: | |||
1405 | name = attr.u.str; | |||
1406 | break; | |||
1407 | ||||
1408 | default: | |||
1409 | break; | |||
1410 | } | |||
1411 | } | |||
1412 | } | |||
1413 | ||||
1414 | if (abbrev->has_children) | |||
1415 | nesting_level++; | |||
1416 | } | |||
1417 | ||||
1418 | return TRUE1; | |||
1419 | } | |||
1420 | ||||
1421 | /* Parse a DWARF2 compilation unit starting at INFO_PTR. This | |||
1422 | includes the compilation unit header that proceeds the DIE's, but | |||
1423 | does not include the length field that precedes each compilation | |||
1424 | unit header. END_PTR points one past the end of this comp unit. | |||
1425 | OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes). | |||
1426 | ||||
1427 | This routine does not read the whole compilation unit; only enough | |||
1428 | to get to the line number information for the compilation unit. */ | |||
1429 | ||||
1430 | static struct comp_unit * | |||
1431 | parse_comp_unit (bfd *abfd, | |||
1432 | struct dwarf2_debug *stash, | |||
1433 | bfd_vma unit_length, | |||
1434 | unsigned int offset_size) | |||
1435 | { | |||
1436 | struct comp_unit* unit; | |||
1437 | unsigned int version; | |||
1438 | bfd_uint64_t abbrev_offset = 0; | |||
1439 | unsigned int addr_size; | |||
1440 | struct abbrev_info** abbrevs; | |||
1441 | unsigned int abbrev_number, bytes_read, i; | |||
1442 | struct abbrev_info *abbrev; | |||
1443 | struct attribute attr; | |||
1444 | char *info_ptr = stash->info_ptr; | |||
1445 | char *end_ptr = info_ptr + unit_length; | |||
1446 | bfd_size_type amt; | |||
1447 | ||||
1448 | version = read_2_bytes (abfd, info_ptr); | |||
1449 | info_ptr += 2; | |||
1450 | BFD_ASSERT (offset_size == 4 || offset_size == 8){ if (!(offset_size == 4 || offset_size == 8)) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/dwarf2.c" ,1450); }; | |||
1451 | if (offset_size
| |||
1452 | abbrev_offset = read_4_bytes (abfd, info_ptr); | |||
1453 | else | |||
1454 | abbrev_offset = read_8_bytes (abfd, info_ptr); | |||
1455 | info_ptr += offset_size; | |||
1456 | addr_size = read_1_byte (abfd, info_ptr); | |||
1457 | info_ptr += 1; | |||
1458 | ||||
1459 | if (version != 2) | |||
1460 | { | |||
1461 | (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information.")("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information." ), version); | |||
1462 | bfd_set_error (bfd_error_bad_value); | |||
1463 | return 0; | |||
1464 | } | |||
1465 | ||||
1466 | if (addr_size > sizeof (bfd_vma)) | |||
1467 | { | |||
1468 | (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'.")("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'." ), | |||
1469 | addr_size, | |||
1470 | (unsigned int) sizeof (bfd_vma)); | |||
1471 | bfd_set_error (bfd_error_bad_value); | |||
1472 | return 0; | |||
1473 | } | |||
1474 | ||||
1475 | if (addr_size != 2 && addr_size != 4 && addr_size != 8) | |||
1476 | { | |||
1477 | (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size); | |||
1478 | bfd_set_error (bfd_error_bad_value); | |||
1479 | return 0; | |||
1480 | } | |||
1481 | ||||
1482 | /* Read the abbrevs for this compilation unit into a table. */ | |||
1483 | abbrevs = read_abbrevs (abfd, abbrev_offset, stash); | |||
1484 | if (! abbrevs) | |||
1485 | return 0; | |||
1486 | ||||
1487 | abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); | |||
1488 | info_ptr += bytes_read; | |||
1489 | if (! abbrev_number) | |||
1490 | { | |||
1491 | (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u.")("Dwarf Error: Bad abbrev number: %u."), | |||
1492 | abbrev_number); | |||
1493 | bfd_set_error (bfd_error_bad_value); | |||
1494 | return 0; | |||
1495 | } | |||
1496 | ||||
1497 | abbrev = lookup_abbrev (abbrev_number, abbrevs); | |||
1498 | if (! abbrev
| |||
1499 | { | |||
1500 | (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u.")("Dwarf Error: Could not find abbrev number %u."), | |||
1501 | abbrev_number); | |||
1502 | bfd_set_error (bfd_error_bad_value); | |||
1503 | return 0; | |||
1504 | } | |||
1505 | ||||
1506 | amt = sizeof (struct comp_unit); | |||
1507 | unit = bfd_zalloc (abfd, amt); | |||
1508 | unit->abfd = abfd; | |||
1509 | unit->addr_size = addr_size; | |||
1510 | unit->offset_size = offset_size; | |||
1511 | unit->abbrevs = abbrevs; | |||
1512 | unit->end_ptr = end_ptr; | |||
1513 | unit->stash = stash; | |||
1514 | ||||
1515 | for (i = 0; i < abbrev->num_attrs; ++i) | |||
1516 | { | |||
1517 | info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr); | |||
1518 | ||||
1519 | /* Store the data if it is of an attribute we want to keep in a | |||
1520 | partial symbol table. */ | |||
1521 | switch (attr.name) | |||
1522 | { | |||
1523 | case DW_AT_stmt_list: | |||
1524 | unit->stmtlist = 1; | |||
1525 | unit->line_offset = attr.u.val; | |||
| ||||
1526 | break; | |||
1527 | ||||
1528 | case DW_AT_name: | |||
1529 | unit->name = attr.u.str; | |||
1530 | break; | |||
1531 | ||||
1532 | case DW_AT_low_pc: | |||
1533 | unit->arange.low = attr.u.val; | |||
1534 | break; | |||
1535 | ||||
1536 | case DW_AT_high_pc: | |||
1537 | unit->arange.high = attr.u.val; | |||
1538 | break; | |||
1539 | ||||
1540 | case DW_AT_comp_dir: | |||
1541 | { | |||
1542 | char* comp_dir = attr.u.str; | |||
1543 | if (comp_dir) | |||
1544 | { | |||
1545 | /* Irix 6.2 native cc prepends <machine>.: to the compilation | |||
1546 | directory, get rid of it. */ | |||
1547 | char *cp = strchr (comp_dir, ':'); | |||
1548 | ||||
1549 | if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/') | |||
1550 | comp_dir = cp + 1; | |||
1551 | } | |||
1552 | unit->comp_dir = comp_dir; | |||
1553 | break; | |||
1554 | } | |||
1555 | ||||
1556 | default: | |||
1557 | break; | |||
1558 | } | |||
1559 | } | |||
1560 | ||||
1561 | unit->first_child_die_ptr = info_ptr; | |||
1562 | return unit; | |||
1563 | } | |||
1564 | ||||
1565 | /* Return TRUE if UNIT contains the address given by ADDR. */ | |||
1566 | ||||
1567 | static bfd_boolean | |||
1568 | comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr) | |||
1569 | { | |||
1570 | struct arange *arange; | |||
1571 | ||||
1572 | if (unit->error) | |||
1573 | return FALSE0; | |||
1574 | ||||
1575 | arange = &unit->arange; | |||
1576 | do | |||
1577 | { | |||
1578 | if (addr >= arange->low && addr < arange->high) | |||
1579 | return TRUE1; | |||
1580 | arange = arange->next; | |||
1581 | } | |||
1582 | while (arange); | |||
1583 | ||||
1584 | return FALSE0; | |||
1585 | } | |||
1586 | ||||
1587 | /* If UNIT contains ADDR, set the output parameters to the values for | |||
1588 | the line containing ADDR. The output parameters, FILENAME_PTR, | |||
1589 | FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects | |||
1590 | to be filled in. | |||
1591 | ||||
1592 | Return TRUE if UNIT contains ADDR, and no errors were encountered; | |||
1593 | FALSE otherwise. */ | |||
1594 | ||||
1595 | static bfd_boolean | |||
1596 | comp_unit_find_nearest_line (struct comp_unit *unit, | |||
1597 | bfd_vma addr, | |||
1598 | const char **filename_ptr, | |||
1599 | const char **functionname_ptr, | |||
1600 | unsigned int *linenumber_ptr, | |||
1601 | struct dwarf2_debug *stash) | |||
1602 | { | |||
1603 | bfd_boolean line_p; | |||
1604 | bfd_boolean func_p; | |||
1605 | struct funcinfo *function; | |||
1606 | ||||
1607 | if (unit->error) | |||
1608 | return FALSE0; | |||
1609 | ||||
1610 | if (! unit->line_table) | |||
1611 | { | |||
1612 | if (! unit->stmtlist) | |||
1613 | { | |||
1614 | unit->error = 1; | |||
1615 | return FALSE0; | |||
1616 | } | |||
1617 | ||||
1618 | unit->line_table = decode_line_info (unit, stash); | |||
1619 | ||||
1620 | if (! unit->line_table) | |||
1621 | { | |||
1622 | unit->error = 1; | |||
1623 | return FALSE0; | |||
1624 | } | |||
1625 | ||||
1626 | if (unit->first_child_die_ptr < unit->end_ptr | |||
1627 | && ! scan_unit_for_functions (unit)) | |||
1628 | { | |||
1629 | unit->error = 1; | |||
1630 | return FALSE0; | |||
1631 | } | |||
1632 | } | |||
1633 | ||||
1634 | function = NULL((void*)0); | |||
1635 | func_p = lookup_address_in_function_table (unit->function_table, addr, | |||
1636 | &function, functionname_ptr); | |||
1637 | line_p = lookup_address_in_line_info_table (unit->line_table, addr, | |||
1638 | function, filename_ptr, | |||
1639 | linenumber_ptr); | |||
1640 | return line_p || func_p; | |||
1641 | } | |||
1642 | ||||
1643 | /* Locate a section in a BFD containing debugging info. The search starts | |||
1644 | from the section after AFTER_SEC, or from the first section in the BFD if | |||
1645 | AFTER_SEC is NULL. The search works by examining the names of the | |||
1646 | sections. There are two permissiable names. The first is .debug_info. | |||
1647 | This is the standard DWARF2 name. The second is a prefix .gnu.linkonce.wi. | |||
1648 | This is a variation on the .debug_info section which has a checksum | |||
1649 | describing the contents appended onto the name. This allows the linker to | |||
1650 | identify and discard duplicate debugging sections for different | |||
1651 | compilation units. */ | |||
1652 | #define DWARF2_DEBUG_INFO".debug_info" ".debug_info" | |||
1653 | #define GNU_LINKONCE_INFO".gnu.linkonce.wi." ".gnu.linkonce.wi." | |||
1654 | ||||
1655 | static asection * | |||
1656 | find_debug_info (bfd *abfd, asection *after_sec) | |||
1657 | { | |||
1658 | asection * msec; | |||
1659 | ||||
1660 | if (after_sec) | |||
1661 | msec = after_sec->next; | |||
1662 | else | |||
1663 | msec = abfd->sections; | |||
1664 | ||||
1665 | while (msec) | |||
1666 | { | |||
1667 | if (strcmp (msec->name, DWARF2_DEBUG_INFO".debug_info") == 0) | |||
1668 | return msec; | |||
1669 | ||||
1670 | if (strncmp (msec->name, GNU_LINKONCE_INFO".gnu.linkonce.wi.", strlen (GNU_LINKONCE_INFO".gnu.linkonce.wi.")) == 0) | |||
1671 | return msec; | |||
1672 | ||||
1673 | msec = msec->next; | |||
1674 | } | |||
1675 | ||||
1676 | return NULL((void*)0); | |||
1677 | } | |||
1678 | ||||
1679 | /* The DWARF2 version of find_nearest line. Return TRUE if the line | |||
1680 | is found without error. ADDR_SIZE is the number of bytes in the | |||
1681 | initial .debug_info length field and in the abbreviation offset. | |||
1682 | You may use zero to indicate that the default value should be | |||
1683 | used. */ | |||
1684 | ||||
1685 | bfd_boolean | |||
1686 | _bfd_dwarf2_find_nearest_line (bfd *abfd, | |||
1687 | asection *section, | |||
1688 | asymbol **symbols, | |||
1689 | bfd_vma offset, | |||
1690 | const char **filename_ptr, | |||
1691 | const char **functionname_ptr, | |||
1692 | unsigned int *linenumber_ptr, | |||
1693 | unsigned int addr_size, | |||
1694 | void **pinfo) | |||
1695 | { | |||
1696 | /* Read each compilation unit from the section .debug_info, and check | |||
1697 | to see if it contains the address we are searching for. If yes, | |||
1698 | lookup the address, and return the line number info. If no, go | |||
1699 | on to the next compilation unit. | |||
1700 | ||||
1701 | We keep a list of all the previously read compilation units, and | |||
1702 | a pointer to the next un-read compilation unit. Check the | |||
1703 | previously read units before reading more. */ | |||
1704 | struct dwarf2_debug *stash = *pinfo; | |||
1705 | ||||
1706 | /* What address are we looking for? */ | |||
1707 | bfd_vma addr = offset + section->vma; | |||
1708 | ||||
1709 | struct comp_unit* each; | |||
1710 | ||||
1711 | *filename_ptr = NULL((void*)0); | |||
1712 | *functionname_ptr = NULL((void*)0); | |||
1713 | *linenumber_ptr = 0; | |||
1714 | ||||
1715 | /* The DWARF2 spec says that the initial length field, and the | |||
1716 | offset of the abbreviation table, should both be 4-byte values. | |||
1717 | However, some compilers do things differently. */ | |||
1718 | if (addr_size == 0) | |||
| ||||
1719 | addr_size = 4; | |||
1720 | BFD_ASSERT (addr_size == 4 || addr_size == 8){ if (!(addr_size == 4 || addr_size == 8)) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/dwarf2.c" ,1720); }; | |||
1721 | ||||
1722 | if (! stash) | |||
1723 | { | |||
1724 | bfd_size_type total_size; | |||
1725 | asection *msec; | |||
1726 | bfd_size_type amt = sizeof (struct dwarf2_debug); | |||
1727 | ||||
1728 | stash = bfd_zalloc (abfd, amt); | |||
1729 | if (! stash) | |||
1730 | return FALSE0; | |||
1731 | ||||
1732 | *pinfo = stash; | |||
1733 | ||||
1734 | msec = find_debug_info (abfd, NULL((void*)0)); | |||
1735 | if (! msec) | |||
1736 | /* No dwarf2 info. Note that at this point the stash | |||
1737 | has been allocated, but contains zeros, this lets | |||
1738 | future calls to this function fail quicker. */ | |||
1739 | return FALSE0; | |||
1740 | ||||
1741 | /* There can be more than one DWARF2 info section in a BFD these days. | |||
1742 | Read them all in and produce one large stash. We do this in two | |||
1743 | passes - in the first pass we just accumulate the section sizes. | |||
1744 | In the second pass we read in the section's contents. The allows | |||
1745 | us to avoid reallocing the data as we add sections to the stash. */ | |||
1746 | for (total_size = 0; msec; msec = find_debug_info (abfd, msec)) | |||
1747 | total_size += msec->_raw_size; | |||
1748 | ||||
1749 | stash->info_ptr = bfd_alloc (abfd, total_size); | |||
1750 | if (stash->info_ptr == NULL((void*)0)) | |||
1751 | return FALSE0; | |||
1752 | ||||
1753 | stash->info_ptr_end = stash->info_ptr; | |||
1754 | ||||
1755 | for (msec = find_debug_info (abfd, NULL((void*)0)); | |||
1756 | msec; | |||
1757 | msec = find_debug_info (abfd, msec)) | |||
1758 | { | |||
1759 | bfd_size_type size; | |||
1760 | bfd_size_type start; | |||
1761 | ||||
1762 | size = msec->_raw_size; | |||
1763 | if (size == 0) | |||
1764 | continue; | |||
1765 | ||||
1766 | start = stash->info_ptr_end - stash->info_ptr; | |||
1767 | ||||
1768 | if ((bfd_simple_get_relocated_section_contents | |||
1769 | (abfd, msec, stash->info_ptr + start, symbols)) == NULL((void*)0)) | |||
1770 | continue; | |||
1771 | ||||
1772 | stash->info_ptr_end = stash->info_ptr + start + size; | |||
1773 | } | |||
1774 | ||||
1775 | BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size){ if (!(stash->info_ptr_end == stash->info_ptr + total_size )) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/dwarf2.c",1775 ); }; | |||
1776 | ||||
1777 | stash->sec = find_debug_info (abfd, NULL((void*)0)); | |||
1778 | stash->sec_info_ptr = stash->info_ptr; | |||
1779 | stash->syms = symbols; | |||
1780 | } | |||
1781 | ||||
1782 | /* A null info_ptr indicates that there is no dwarf2 info | |||
1783 | (or that an error occured while setting up the stash). */ | |||
1784 | if (! stash->info_ptr) | |||
1785 | return FALSE0; | |||
1786 | ||||
1787 | /* Check the previously read comp. units first. */ | |||
1788 | for (each = stash->all_comp_units; each; each = each->next_unit) | |||
1789 | if (comp_unit_contains_address (each, addr)) | |||
1790 | return comp_unit_find_nearest_line (each, addr, filename_ptr, | |||
1791 | functionname_ptr, linenumber_ptr, | |||
1792 | stash); | |||
1793 | ||||
1794 | /* Read each remaining comp. units checking each as they are read. */ | |||
1795 | while (stash->info_ptr < stash->info_ptr_end) | |||
1796 | { | |||
1797 | bfd_vma length; | |||
1798 | bfd_boolean found; | |||
1799 | unsigned int offset_size = addr_size; | |||
1800 | ||||
1801 | length = read_4_bytes (abfd, stash->info_ptr); | |||
1802 | /* A 0xffffff length is the DWARF3 way of indicating we use | |||
1803 | 64-bit offsets, instead of 32-bit offsets. */ | |||
1804 | if (length == 0xffffffff) | |||
1805 | { | |||
1806 | offset_size = 8; | |||
1807 | length = read_8_bytes (abfd, stash->info_ptr + 4); | |||
1808 | stash->info_ptr += 12; | |||
1809 | } | |||
1810 | /* A zero length is the IRIX way of indicating 64-bit offsets, | |||
1811 | mostly because the 64-bit length will generally fit in 32 | |||
1812 | bits, and the endianness helps. */ | |||
1813 | else if (length == 0) | |||
1814 | { | |||
1815 | offset_size = 8; | |||
1816 | length = read_4_bytes (abfd, stash->info_ptr + 4); | |||
1817 | stash->info_ptr += 8; | |||
1818 | } | |||
1819 | /* In the absence of the hints above, we assume addr_size-sized | |||
1820 | offsets, for backward-compatibility with pre-DWARF3 64-bit | |||
1821 | platforms. */ | |||
1822 | else if (addr_size
| |||
1823 | { | |||
1824 | length = read_8_bytes (abfd, stash->info_ptr); | |||
1825 | stash->info_ptr += 8; | |||
1826 | } | |||
1827 | else | |||
1828 | stash->info_ptr += 4; | |||
1829 | ||||
1830 | if (length
| |||
1831 | { | |||
1832 | each = parse_comp_unit (abfd, stash, length, offset_size); | |||
1833 | stash->info_ptr += length; | |||
1834 | ||||
1835 | if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr) | |||
1836 | == stash->sec->_raw_size) | |||
1837 | { | |||
1838 | stash->sec = find_debug_info (abfd, stash->sec); | |||
1839 | stash->sec_info_ptr = stash->info_ptr; | |||
1840 | } | |||
1841 | ||||
1842 | if (each) | |||
1843 | { | |||
1844 | each->next_unit = stash->all_comp_units; | |||
1845 | stash->all_comp_units = each; | |||
1846 | ||||
1847 | /* DW_AT_low_pc and DW_AT_high_pc are optional for | |||
1848 | compilation units. If we don't have them (i.e., | |||
1849 | unit->high == 0), we need to consult the line info | |||
1850 | table to see if a compilation unit contains the given | |||
1851 | address. */ | |||
1852 | if (each->arange.high > 0) | |||
1853 | { | |||
1854 | if (comp_unit_contains_address (each, addr)) | |||
1855 | return comp_unit_find_nearest_line (each, addr, | |||
1856 | filename_ptr, | |||
1857 | functionname_ptr, | |||
1858 | linenumber_ptr, | |||
1859 | stash); | |||
1860 | } | |||
1861 | else | |||
1862 | { | |||
1863 | found = comp_unit_find_nearest_line (each, addr, | |||
1864 | filename_ptr, | |||
1865 | functionname_ptr, | |||
1866 | linenumber_ptr, | |||
1867 | stash); | |||
1868 | if (found) | |||
1869 | return TRUE1; | |||
1870 | } | |||
1871 | } | |||
1872 | } | |||
1873 | } | |||
1874 | ||||
1875 | return FALSE0; | |||
1876 | } |