bfd/dwarf1.c

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