bfd/dwarf1.c

   1 /* DWARF 1 find nearest line (_bfd_dwarf1_find_nearest_line).
   2    Copyright (C) 1998-2021 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   size_t 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   size_t 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 bool
 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 int   block_len;
 217       unsigned short attr;
 218
 219       /* Parse the attribute based on its form.  This section
 220          must handle all dwarf1 forms, but need only handle the
 221          actual attributes that we care about.  */
 222       attr = bfd_get_16 (abfd, xptr);
 223       xptr += 2;
 224
 225       switch (FORM_FROM_ATTR (attr))
 226         {
 227         case FORM_DATA2:
 228           xptr += 2;
 229           break;
 230         case FORM_DATA4:
 231         case FORM_REF:
 232           if (xptr + 4 <= aDiePtrEnd)
 233             {
 234               if (attr == AT_sibling)
 235                 aDieInfo->sibling = bfd_get_32 (abfd, xptr);
 236               else if (attr == AT_stmt_list)
 237                 {
 238                   aDieInfo->stmt_list_offset = bfd_get_32 (abfd, xptr);
 239                   aDieInfo->has_stmt_list = 1;
 240                 }
 241             }
 242           xptr += 4;
 243           break;
 244         case FORM_DATA8:
 245           xptr += 8;
 246           break;
 247         case FORM_ADDR:
 248           if (xptr + 4 <= aDiePtrEnd)
 249             {
 250               if (attr == AT_low_pc)
 251                 aDieInfo->low_pc = bfd_get_32 (abfd, xptr);
 252               else if (attr == AT_high_pc)
 253                 aDieInfo->high_pc = bfd_get_32 (abfd, xptr);
 254             }
 255           xptr += 4;
 256           break;
 257         case FORM_BLOCK2:
 258           if (xptr + 2 <= aDiePtrEnd)
 259             {
 260               block_len = bfd_get_16 (abfd, xptr);
 261               if (xptr + block_len > aDiePtrEnd
 262                   || xptr + block_len < xptr)
 263                 return false;
 264               xptr += block_len;
 265             }
 266           xptr += 2;
 267           break;
 268         case FORM_BLOCK4:
 269           if (xptr + 4 <= aDiePtrEnd)
 270             {
 271               block_len = bfd_get_32 (abfd, xptr);
 272               if (xptr + block_len > aDiePtrEnd
 273                   || xptr + block_len < xptr)
 274                 return false;
 275               xptr += block_len;
 276             }
 277           xptr += 4;
 278           break;
 279         case FORM_STRING:
 280           if (attr == AT_name)
 281             aDieInfo->name = (char *) xptr;
 282           xptr += strnlen ((char *) xptr, aDiePtrEnd - xptr) + 1;
 283           break;
 284         }
 285     }
 286
 287   return true;
 288 }
 289
 290 /* Parse a dwarf1 line number table for 'aUnit->stmt_list_offset'
 291    into 'aUnit->linenumber_table'.  Return FALSE if an error
 292    occurs; TRUE otherwise.  */
 293
 294 static bool
 295 parse_line_table (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
 296 {
 297   bfd_byte *xptr;
 298
 299   /* Load the ".line" section from the bfd if we haven't already.  */
 300   if (stash->line_section == 0)
 301     {
 302       asection *msec;
 303       bfd_size_type size;
 304
 305       msec = bfd_get_section_by_name (stash->abfd, ".line");
 306       if (! msec)
 307         return false;
 308
 309       size = msec->rawsize ? msec->rawsize : msec->size;
 310       stash->line_section
 311         = bfd_simple_get_relocated_section_contents
 312         (stash->abfd, msec, NULL, stash->syms);
 313
 314       if (! stash->line_section)
 315         return false;
 316
 317       stash->line_section_end = stash->line_section + size;
 318     }
 319
 320   xptr = stash->line_section + aUnit->stmt_list_offset;
 321   if (xptr + 8 <= stash->line_section_end)
 322     {
 323       unsigned long eachLine;
 324       bfd_byte *tblend;
 325       unsigned long base;
 326       bfd_size_type amt;
 327
 328       /* First comes the length.  */
 329       tblend = bfd_get_32 (stash->abfd, (bfd_byte *) xptr) + xptr;
 330       xptr += 4;
 331
 332       /* Then the base address for each address in the table.  */
 333       base = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
 334       xptr += 4;
 335
 336       /* How many line entrys?
 337          10 = 4 (line number) + 2 (pos in line) + 4 (address in line).  */
 338       aUnit->line_count = (tblend - xptr) / 10;
 339
 340       /* Allocate an array for the entries.  */
 341       amt = sizeof (struct linenumber) * aUnit->line_count;
 342       aUnit->linenumber_table = (struct linenumber *) bfd_alloc (stash->abfd,
 343                                                                  amt);
 344       if (!aUnit->linenumber_table)
 345         return false;
 346
 347       for (eachLine = 0; eachLine < aUnit->line_count; eachLine++)
 348         {
 349           if (xptr + 10 > stash->line_section_end)
 350             {
 351               aUnit->line_count = eachLine;
 352               break;
 353             }
 354           /* A line number.  */
 355           aUnit->linenumber_table[eachLine].linenumber
 356             = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
 357           xptr += 4;
 358
 359           /* Skip the position within the line.  */
 360           xptr += 2;
 361
 362           /* And finally the address.  */
 363           aUnit->linenumber_table[eachLine].addr
 364             = base + bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
 365           xptr += 4;
 366         }
 367     }
 368
 369   return true;
 370 }
 371
 372 /* Parse each function die in a compilation unit 'aUnit'.
 373    The first child die of 'aUnit' should be in 'aUnit->first_child',
 374    the result is placed in 'aUnit->func_list'.
 375    Return FALSE if error; TRUE otherwise.  */
 376
 377 static bool
 378 parse_functions_in_unit (struct dwarf1_debug* stash, struct dwarf1_unit* aUnit)
 379 {
 380   bfd_byte *eachDie;
 381
 382   if (aUnit->first_child)
 383     for (eachDie = aUnit->first_child;
 384          eachDie < stash->debug_section_end;
 385          )
 386       {
 387         struct die_info eachDieInfo;
 388
 389         if (! parse_die (stash->abfd, &eachDieInfo, eachDie,
 390                          stash->debug_section_end))
 391           return false;
 392
 393         if (eachDieInfo.tag == TAG_global_subroutine
 394             || eachDieInfo.tag == TAG_subroutine
 395             || eachDieInfo.tag == TAG_inlined_subroutine
 396             || eachDieInfo.tag == TAG_entry_point)
 397           {
 398             struct dwarf1_func* aFunc = alloc_dwarf1_func (stash,aUnit);
 399             if (!aFunc)
 400               return false;
 401
 402             aFunc->name = eachDieInfo.name;
 403             aFunc->low_pc = eachDieInfo.low_pc;
 404             aFunc->high_pc = eachDieInfo.high_pc;
 405           }
 406
 407         /* Move to next sibling, if none, end loop */
 408         if (eachDieInfo.sibling)
 409           eachDie = stash->debug_section + eachDieInfo.sibling;
 410         else
 411           break;
 412       }
 413
 414   return true;
 415 }
 416
 417 /* Find the nearest line to 'addr' in 'aUnit'.
 418    Return whether we found the line (or a function) without error.  */
 419
 420 static bool
 421 dwarf1_unit_find_nearest_line (struct dwarf1_debug* stash,
 422                                struct dwarf1_unit* aUnit,
 423                                unsigned long addr,
 424                                const char **filename_ptr,
 425                                const char **functionname_ptr,
 426                                unsigned int *linenumber_ptr)
 427 {
 428   int line_p = false;
 429   int func_p = false;
 430
 431   if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
 432     {
 433       if (aUnit->has_stmt_list)
 434         {
 435           unsigned long i;
 436           struct dwarf1_func* eachFunc;
 437
 438           if (! aUnit->linenumber_table)
 439             {
 440               if (! parse_line_table (stash, aUnit))
 441                 return false;
 442             }
 443
 444           if (! aUnit->func_list)
 445             {
 446               if (! parse_functions_in_unit (stash, aUnit))
 447                 return false;
 448             }
 449
 450           for (i = 0; i < aUnit->line_count; i++)
 451             {
 452               if (aUnit->linenumber_table[i].addr <= addr
 453                   && addr < aUnit->linenumber_table[i+1].addr)
 454                 {
 455                   *filename_ptr = aUnit->name;
 456                   *linenumber_ptr = aUnit->linenumber_table[i].linenumber;
 457                   line_p = true;
 458                   break;
 459                 }
 460             }
 461
 462           for (eachFunc = aUnit->func_list;
 463                eachFunc;
 464                eachFunc = eachFunc->prev)
 465             {
 466               if (eachFunc->low_pc <= addr
 467                   && addr < eachFunc->high_pc)
 468                 {
 469                   *functionname_ptr = eachFunc->name;
 470                   func_p = true;
 471                   break;
 472                 }
 473             }
 474         }
 475     }
 476
 477   return line_p || func_p;
 478 }
 479
 480 /* The DWARF 1 version of find_nearest line.
 481    Return TRUE if the line is found without error.  */
 482
 483 bool
 484 _bfd_dwarf1_find_nearest_line (bfd *abfd,
 485                                asymbol **symbols,
 486                                asection *section,
 487                                bfd_vma offset,
 488                                const char **filename_ptr,
 489                                const char **functionname_ptr,
 490                                unsigned int *linenumber_ptr)
 491 {
 492   struct dwarf1_debug *stash = elf_tdata (abfd)->dwarf1_find_line_info;
 493
 494   struct dwarf1_unit* eachUnit;
 495
 496   /* What address are we looking for? */
 497   unsigned long addr = (unsigned long)(offset + section->vma);
 498
 499   *filename_ptr = NULL;
 500   *functionname_ptr = NULL;
 501   *linenumber_ptr = 0;
 502
 503   if (! stash)
 504     {
 505       asection *msec;
 506       bfd_size_type size = sizeof (struct dwarf1_debug);
 507
 508       stash = elf_tdata (abfd)->dwarf1_find_line_info
 509         = (struct dwarf1_debug *) bfd_zalloc (abfd, size);
 510
 511       if (! stash)
 512         return false;
 513
 514       msec = bfd_get_section_by_name (abfd, ".debug");
 515       if (! msec)
 516         /* No dwarf1 info.  Note that at this point the stash
 517            has been allocated, but contains zeros, this lets
 518            future calls to this function fail quicker.  */
 519         return false;
 520
 521       size = msec->rawsize ? msec->rawsize : msec->size;
 522       stash->debug_section
 523         = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
 524                                                      symbols);
 525
 526       if (! stash->debug_section)
 527         return false;
 528
 529       stash->debug_section_end = stash->debug_section + size;
 530       stash->currentDie = stash->debug_section;
 531       stash->abfd = abfd;
 532       stash->syms = symbols;
 533     }
 534
 535   /* A null debug_section indicates that there was no dwarf1 info
 536      or that an error occured while setting up the stash.  */
 537
 538   if (! stash->debug_section)
 539     return false;
 540
 541   /* Look at the previously parsed units to see if any contain
 542      the addr.  */
 543   for (eachUnit = stash->lastUnit; eachUnit; eachUnit = eachUnit->prev)
 544     if (eachUnit->low_pc <= addr && addr < eachUnit->high_pc)
 545       return dwarf1_unit_find_nearest_line (stash, eachUnit, addr,
 546                                             filename_ptr,
 547                                             functionname_ptr,
 548                                             linenumber_ptr);
 549
 550   while (stash->currentDie < stash->debug_section_end)
 551     {
 552       struct die_info aDieInfo;
 553
 554       if (! parse_die (stash->abfd, &aDieInfo, stash->currentDie,
 555                        stash->debug_section_end))
 556         return false;
 557
 558       if (aDieInfo.tag == TAG_compile_unit)
 559         {
 560           struct dwarf1_unit* aUnit
 561             = alloc_dwarf1_unit (stash);
 562           if (!aUnit)
 563             return false;
 564
 565           aUnit->name = aDieInfo.name;
 566           aUnit->low_pc = aDieInfo.low_pc;
 567           aUnit->high_pc = aDieInfo.high_pc;
 568           aUnit->has_stmt_list = aDieInfo.has_stmt_list;
 569           aUnit->stmt_list_offset = aDieInfo.stmt_list_offset;
 570
 571           /* A die has a child if it's followed by a die that is
 572              not it's sibling.  */
 573           if (aDieInfo.sibling
 574               && stash->currentDie + aDieInfo.length
 575                     < stash->debug_section_end
 576               && stash->currentDie + aDieInfo.length
 577                     != stash->debug_section + aDieInfo.sibling)
 578             aUnit->first_child = stash->currentDie + aDieInfo.length;
 579           else
 580             aUnit->first_child = 0;
 581
 582           if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
 583             return dwarf1_unit_find_nearest_line (stash, aUnit, addr,
 584                                                   filename_ptr,
 585                                                   functionname_ptr,
 586                                                   linenumber_ptr);
 587         }
 588
 589       if (aDieInfo.sibling != 0)
 590         stash->currentDie = stash->debug_section + aDieInfo.sibling;
 591       else
 592         stash->currentDie += aDieInfo.length;
 593     }
 594
 595   return false;
 596 }