dwarf1.c revision 77298
1/* DWARF 1 find nearest line (_bfd_dwarf1_find_nearest_line). 2 Copyright 1998, 1999, 2000 Free Software Foundation, Inc. 3 4Written by Gavin Romig-Koch of Cygnus Solutions (gavin@cygnus.com). 5 6This file is part of BFD. 7 8This program is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2 of the License, or (at 11your option) any later version. 12 13This program is distributed in the hope that it will be useful, but 14WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with this program; if not, write to the Free Software 20Foundation, 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 31struct 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 58struct 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 90struct 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. */ 103struct 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. */ 118struct 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) /* Implicitly specified */ 128 129/* Return a newly allocated dwarf1_unit. It should be cleared and 130 then attached into the 'stash' at 'stash->lastUnit'. */ 131 132static struct dwarf1_unit* 133alloc_dwarf1_unit (stash) 134 struct dwarf1_debug* stash; 135{ 136 struct dwarf1_unit* x = 137 (struct dwarf1_unit*) bfd_zalloc (stash->abfd, 138 sizeof (struct dwarf1_unit)); 139 x->prev = stash->lastUnit; 140 stash->lastUnit = x; 141 142 return x; 143} 144 145/* Return a newly allocated dwarf1_func. It must be cleared and 146 attached into 'aUnit' at 'aUnit->func_list'. */ 147 148static struct dwarf1_func* 149alloc_dwarf1_func (stash, aUnit) 150 struct dwarf1_debug* stash; 151 struct dwarf1_unit* aUnit; 152{ 153 struct dwarf1_func* x = 154 (struct dwarf1_func*) bfd_zalloc (stash->abfd, 155 sizeof (struct dwarf1_func)); 156 x->prev = aUnit->func_list; 157 aUnit->func_list = x; 158 159 return x; 160} 161 162/* parse_die - parse a Dwarf1 die. 163 Parse the die starting at 'aDiePtr' into 'aDieInfo'. 164 'abfd' must be the bfd from which the section that 'aDiePtr' 165 points to was pulled from. 166 167 Return false if the die is invalidly formatted; true otherwise. */ 168 169static boolean 170parse_die (abfd, aDieInfo, aDiePtr) 171 bfd* abfd; 172 struct die_info* aDieInfo; 173 char* aDiePtr; 174{ 175 char* this_die = aDiePtr; 176 char* xptr = this_die; 177 178 memset (aDieInfo,0,sizeof (*aDieInfo)); 179 180 /* First comes the length. */ 181 aDieInfo->length = bfd_get_32 (abfd, (bfd_byte *) xptr); 182 xptr += 4; 183 if (aDieInfo->length == 0) 184 return false; 185 if (aDieInfo->length < 6) 186 { 187 /* Just padding bytes. */ 188 aDieInfo->tag = TAG_padding; 189 return true; 190 } 191 192 /* Then the tag. */ 193 aDieInfo->tag = bfd_get_16 (abfd, (bfd_byte *) xptr); 194 xptr += 2; 195 196 /* Then the attributes. */ 197 while (xptr < (this_die + aDieInfo->length)) 198 { 199 unsigned short attr; 200 201 /* Parse the attribute based on its form. This section 202 must handle all dwarf1 forms, but need only handle the 203 actual attributes that we care about. */ 204 205 attr = bfd_get_16 (abfd, (bfd_byte *) xptr); 206 xptr += 2; 207 208 switch (FORM_FROM_ATTR (attr)) 209 { 210 case FORM_DATA2: 211 xptr += 2; 212 break; 213 case FORM_DATA4: 214 case FORM_REF: 215 if (attr == AT_sibling) 216 aDieInfo->sibling = bfd_get_32 (abfd, (bfd_byte *) xptr); 217 else if (attr == AT_stmt_list) 218 { 219 aDieInfo->stmt_list_offset = bfd_get_32 (abfd, (bfd_byte *) xptr); 220 aDieInfo->has_stmt_list = 1; 221 } 222 xptr += 4; 223 break; 224 case FORM_DATA8: 225 xptr += 8; 226 break; 227 case FORM_ADDR: 228 if (attr == AT_low_pc) 229 aDieInfo->low_pc = bfd_get_32 (abfd, (bfd_byte *) xptr); 230 else if (attr == AT_high_pc) 231 aDieInfo->high_pc = bfd_get_32 (abfd, (bfd_byte *) xptr); 232 xptr += 4; 233 break; 234 case FORM_BLOCK2: 235 xptr += 2 + bfd_get_16 (abfd, (bfd_byte *) xptr); 236 break; 237 case FORM_BLOCK4: 238 xptr += 4 + bfd_get_32 (abfd, (bfd_byte *) xptr); 239 break; 240 case FORM_STRING: 241 if (attr == AT_name) 242 aDieInfo->name = xptr; 243 xptr += strlen (xptr) + 1; 244 break; 245 } 246 } 247 248 return true; 249} 250 251/* Parse a dwarf1 line number table for 'aUnit->stmt_list_offset' 252 into 'aUnit->linenumber_table'. Return false if an error 253 occurs; true otherwise. */ 254 255static boolean 256parse_line_table (stash, aUnit) 257 struct dwarf1_debug* stash; 258 struct dwarf1_unit* aUnit; 259{ 260 char* xptr; 261 262 /* Load the ".line" section from the bfd if we haven't already. */ 263 if (stash->line_section == 0) 264 { 265 asection *msec; 266 unsigned long size; 267 268 msec = bfd_get_section_by_name (stash->abfd, ".line"); 269 if (! msec) 270 return false; 271 272 size = bfd_get_section_size_before_reloc (msec); 273 stash->line_section = (char *) bfd_alloc (stash->abfd, size); 274 275 if (! stash->line_section) 276 return false; 277 278 if (! bfd_get_section_contents (stash->abfd, msec, stash->line_section, 0, size)) 279 { 280 stash->line_section = 0; 281 return false; 282 } 283 284 stash->line_section_end = stash->line_section + size; 285 } 286 287 xptr = stash->line_section + aUnit->stmt_list_offset; 288 if (xptr < stash->line_section_end) 289 { 290 unsigned long eachLine; 291 292 char* tblend; 293 unsigned long base; 294 295 /* First comes the length. */ 296 tblend = bfd_get_32 (stash->abfd, (bfd_byte *) xptr) + xptr; 297 xptr += 4; 298 299 /* Then the base address for each address in the table. */ 300 base = bfd_get_32 (stash->abfd, (bfd_byte *) xptr); 301 xptr += 4; 302 303 /* How many line entrys? 304 10 = 4 (line number) + 2 (pos in line) + 4 (address in line) */ 305 aUnit->line_count = (tblend - xptr) / 10; 306 307 /* Allocate an array for the entries. */ 308 aUnit->linenumber_table = (struct linenumber *) 309 bfd_alloc (stash->abfd, 310 sizeof (struct linenumber) * aUnit->line_count); 311 312 for (eachLine = 0; eachLine < aUnit->line_count; eachLine++) 313 { 314 /* A line number. */ 315 aUnit->linenumber_table[eachLine].linenumber 316 = bfd_get_32 (stash->abfd, (bfd_byte *) xptr); 317 xptr += 4; 318 319 /* Skip the position within the line. */ 320 xptr += 2; 321 322 /* And finally the address. */ 323 aUnit->linenumber_table[eachLine].addr 324 = base + bfd_get_32 (stash->abfd, (bfd_byte *) xptr); 325 xptr += 4; 326 } 327 } 328 329 return true; 330} 331 332/* Parse each function die in a compilation unit 'aUnit'. 333 The first child die of 'aUnit' should be in 'aUnit->first_child', 334 the result is placed in 'aUnit->func_list'. 335 Return false if error; true otherwise. */ 336 337static boolean 338parse_functions_in_unit (stash, aUnit) 339 struct dwarf1_debug* stash; 340 struct dwarf1_unit* aUnit; 341{ 342 char* eachDie; 343 344 if (aUnit->first_child) 345 for (eachDie = aUnit->first_child; 346 eachDie < stash->debug_section_end; 347 ) 348 { 349 struct die_info eachDieInfo; 350 351 if (! parse_die (stash->abfd, &eachDieInfo, eachDie)) 352 return false; 353 354 if (eachDieInfo.tag == TAG_global_subroutine 355 || eachDieInfo.tag == TAG_subroutine 356 || eachDieInfo.tag == TAG_inlined_subroutine 357 || eachDieInfo.tag == TAG_entry_point) 358 { 359 struct dwarf1_func* aFunc = alloc_dwarf1_func (stash,aUnit); 360 361 aFunc->name = eachDieInfo.name; 362 aFunc->low_pc = eachDieInfo.low_pc; 363 aFunc->high_pc = eachDieInfo.high_pc; 364 } 365 366 /* Move to next sibling, if none, end loop */ 367 if (eachDieInfo.sibling) 368 eachDie = stash->debug_section + eachDieInfo.sibling; 369 else 370 break; 371 } 372 373 return true; 374} 375 376/* Find the nearest line to 'addr' in 'aUnit'. 377 Return whether we found the line (or a function) without error. */ 378 379static boolean 380dwarf1_unit_find_nearest_line (stash, aUnit, addr, 381 filename_ptr, functionname_ptr, 382 linenumber_ptr) 383 struct dwarf1_debug* stash; 384 struct dwarf1_unit* aUnit; 385 unsigned long addr; 386 const char **filename_ptr; 387 const char **functionname_ptr; 388 unsigned int *linenumber_ptr; 389{ 390 int line_p = false; 391 int func_p = false; 392 393 if (aUnit->low_pc <= addr && addr < aUnit->high_pc) 394 { 395 if (aUnit->has_stmt_list) 396 { 397 unsigned long i; 398 struct dwarf1_func* eachFunc; 399 400 if (! aUnit->linenumber_table) 401 { 402 if (! parse_line_table (stash, aUnit)) 403 return false; 404 } 405 406 if (! aUnit->func_list) 407 { 408 if (! parse_functions_in_unit (stash, aUnit)) 409 return false; 410 } 411 412 for (i = 0; i < aUnit->line_count; i++) 413 { 414 if (aUnit->linenumber_table[i].addr <= addr 415 && addr < aUnit->linenumber_table[i+1].addr) 416 { 417 *filename_ptr = aUnit->name; 418 *linenumber_ptr = aUnit->linenumber_table[i].linenumber; 419 line_p = true; 420 break; 421 } 422 } 423 424 for (eachFunc = aUnit->func_list; 425 eachFunc; 426 eachFunc = eachFunc->prev) 427 { 428 if (eachFunc->low_pc <= addr 429 && addr < eachFunc->high_pc) 430 { 431 *functionname_ptr = eachFunc->name; 432 func_p = true; 433 break; 434 } 435 } 436 } 437 } 438 439 return line_p || func_p; 440} 441 442/* The DWARF 1 version of find_nearest line. 443 Return true if the line is found without error. */ 444 445boolean 446_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset, 447 filename_ptr, functionname_ptr, linenumber_ptr) 448 bfd *abfd; 449 asection *section; 450 asymbol **symbols ATTRIBUTE_UNUSED; 451 bfd_vma offset; 452 const char **filename_ptr; 453 const char **functionname_ptr; 454 unsigned int *linenumber_ptr; 455{ 456 struct dwarf1_debug *stash = elf_tdata (abfd)->dwarf1_find_line_info; 457 458 struct dwarf1_unit* eachUnit; 459 460 /* What address are we looking for? */ 461 bfd_vma addr = offset + section->vma; 462 463 *filename_ptr = NULL; 464 *functionname_ptr = NULL; 465 *linenumber_ptr = 0; 466 467 if (! stash) 468 { 469 asection *msec; 470 unsigned long size; 471 472 stash = elf_tdata (abfd)->dwarf1_find_line_info = 473 (struct dwarf1_debug*) bfd_zalloc (abfd, sizeof (struct dwarf1_debug)); 474 475 if (! stash) 476 return false; 477 478 msec = bfd_get_section_by_name (abfd, ".debug"); 479 if (! msec) 480 { 481 /* No dwarf1 info. Note that at this point the stash 482 has been allocated, but contains zeros, this lets 483 future calls to this function fail quicker. */ 484 return false; 485 } 486 487 size = bfd_get_section_size_before_reloc (msec); 488 stash->debug_section = (char *) bfd_alloc (abfd, size); 489 490 if (! stash->debug_section) 491 return false; 492 493 if (! bfd_get_section_contents (abfd, msec, stash->debug_section, 0, size)) 494 { 495 stash->debug_section = 0; 496 return false; 497 } 498 499 stash->debug_section_end = stash->debug_section + size; 500 stash->currentDie = stash->debug_section; 501 stash->abfd = abfd; 502 } 503 504 /* A null debug_section indicates that there was no dwarf1 info 505 or that an error occured while setting up the stash. */ 506 507 if (! stash->debug_section) 508 return false; 509 510 /* Look at the previously parsed units to see if any contain 511 the addr. */ 512 for (eachUnit = stash->lastUnit; eachUnit; eachUnit = eachUnit->prev) 513 { 514 if (eachUnit->low_pc <= addr && addr < eachUnit->high_pc) 515 return dwarf1_unit_find_nearest_line (stash, eachUnit, addr, 516 filename_ptr, 517 functionname_ptr, 518 linenumber_ptr); 519 } 520 521 while (stash->currentDie < stash->debug_section_end) 522 { 523 struct die_info aDieInfo; 524 525 if (! parse_die (stash->abfd, &aDieInfo, stash->currentDie)) 526 return false; 527 528 if (aDieInfo.tag == TAG_compile_unit) 529 { 530 struct dwarf1_unit* aUnit 531 = alloc_dwarf1_unit (stash); 532 533 aUnit->name = aDieInfo.name; 534 aUnit->low_pc = aDieInfo.low_pc; 535 aUnit->high_pc = aDieInfo.high_pc; 536 aUnit->has_stmt_list = aDieInfo.has_stmt_list; 537 aUnit->stmt_list_offset = aDieInfo.stmt_list_offset; 538 539 /* A die has a child if it's followed by a die that is 540 not it's sibling. */ 541 if (aDieInfo.sibling 542 && stash->currentDie + aDieInfo.length 543 < stash->debug_section_end 544 && stash->currentDie + aDieInfo.length 545 != stash->debug_section + aDieInfo.sibling) 546 aUnit->first_child = stash->currentDie + aDieInfo.length; 547 else 548 aUnit->first_child = 0; 549 550 if (aUnit->low_pc <= addr && addr < aUnit->high_pc) 551 return dwarf1_unit_find_nearest_line (stash, aUnit, addr, 552 filename_ptr, 553 functionname_ptr, 554 linenumber_ptr); 555 } 556 557 if (aDieInfo.sibling != 0) 558 stash->currentDie = stash->debug_section + aDieInfo.sibling; 559 else 560 stash->currentDie += aDieInfo.length; 561 } 562 563 return false; 564} 565 566/* EOF */ 567