bfd/dwarf1.c

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