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