bfd/dwarf2.c

   1 /* DWARF 2 support.
   2    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   3    2004, 2005, 2006 Free Software Foundation, Inc.
   4
   5    Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
   6    (gavin@cygnus.com).
   7
   8    From the dwarf2read.c header:
   9    Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
  10    Inc.  with support from Florida State University (under contract
  11    with the Ada Joint Program Office), and Silicon Graphics, Inc.
  12    Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
  13    based on Fred Fish's (Cygnus Support) implementation of DWARF 1
  14    support in dwarfread.c
  15
  16    This file is part of BFD.
  17
  18    This program is free software; you can redistribute it and/or modify
  19    it under the terms of the GNU General Public License as published by
  20    the Free Software Foundation; either version 2 of the License, or (at
  21    your option) any later version.
  22
  23    This program is distributed in the hope that it will be useful, but
  24    WITHOUT ANY WARRANTY; without even the implied warranty of
  25    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  26    General Public License for more details.
  27
  28    You should have received a copy of the GNU General Public License
  29    along with this program; if not, write to the Free Software
  30    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  31
  32 #include "bfd.h"
  33 #include "sysdep.h"
  34 #include "libiberty.h"
  35 #include "libbfd.h"
  36 #include "elf-bfd.h"
  37 #include "elf/dwarf2.h"
  38
  39 /* The data in the .debug_line statement prologue looks like this.  */
  40
  41 struct line_head
  42 {
  43   bfd_vma total_length;
  44   unsigned short version;
  45   bfd_vma prologue_length;
  46   unsigned char minimum_instruction_length;
  47   unsigned char default_is_stmt;
  48   int line_base;
  49   unsigned char line_range;
  50   unsigned char opcode_base;
  51   unsigned char *standard_opcode_lengths;
  52 };
  53
  54 /* Attributes have a name and a value.  */
  55
  56 struct attribute
  57 {
  58   enum dwarf_attribute name;
  59   enum dwarf_form form;
  60   union
  61   {
  62     char *str;
  63     struct dwarf_block *blk;
  64     bfd_uint64_t val;
  65     bfd_int64_t sval;
  66   }
  67   u;
  68 };
  69
  70 /* Blocks are a bunch of untyped bytes.  */
  71 struct dwarf_block
  72 {
  73   unsigned int size;
  74   bfd_byte *data;
  75 };
  76
  77 struct loadable_section
  78 {
  79   asection *section;
  80   bfd_vma adj_vma;
  81 };
  82
  83 struct dwarf2_debug
  84 {
  85   /* A list of all previously read comp_units.  */
  86   struct comp_unit *all_comp_units;
  87
  88   /* The next unread compilation unit within the .debug_info section.
  89      Zero indicates that the .debug_info section has not been loaded
  90      into a buffer yet.  */
  91   bfd_byte *info_ptr;
  92
  93   /* Pointer to the end of the .debug_info section memory buffer.  */
  94   bfd_byte *info_ptr_end;
  95
  96   /* Pointer to the section and address of the beginning of the
  97      section.  */
  98   asection *sec;
  99   bfd_byte *sec_info_ptr;
 100
 101   /* Pointer to the symbol table.  */
 102   asymbol **syms;
 103
 104   /* Pointer to the .debug_abbrev section loaded into memory.  */
 105   bfd_byte *dwarf_abbrev_buffer;
 106
 107   /* Length of the loaded .debug_abbrev section.  */
 108   unsigned long dwarf_abbrev_size;
 109
 110   /* Buffer for decode_line_info.  */
 111   bfd_byte *dwarf_line_buffer;
 112
 113   /* Length of the loaded .debug_line section.  */
 114   unsigned long dwarf_line_size;
 115
 116   /* Pointer to the .debug_str section loaded into memory.  */
 117   bfd_byte *dwarf_str_buffer;
 118
 119   /* Length of the loaded .debug_str section.  */
 120   unsigned long dwarf_str_size;
 121
 122   /* Pointer to the .debug_ranges section loaded into memory. */
 123   bfd_byte *dwarf_ranges_buffer;
 124
 125   /* Length of the loaded .debug_ranges section. */
 126   unsigned long dwarf_ranges_size;
 127
 128   /* If the most recent call to bfd_find_nearest_line was given an
 129      address in an inlined function, preserve a pointer into the
 130      calling chain for subsequent calls to bfd_find_inliner_info to
 131      use. */
 132   struct funcinfo *inliner_chain;
 133
 134   /* Number of loadable sections.  */
 135   unsigned int loadable_section_count;
 136
 137   /* Array of loadable sections.  */
 138   struct loadable_section *loadable_sections;
 139 };
 140
 141 struct arange
 142 {
 143   struct arange *next;
 144   bfd_vma low;
 145   bfd_vma high;
 146 };
 147
 148 /* A minimal decoding of DWARF2 compilation units.  We only decode
 149    what's needed to get to the line number information.  */
 150
 151 struct comp_unit
 152 {
 153   /* Chain the previously read compilation units.  */
 154   struct comp_unit *next_unit;
 155
 156   /* Keep the bfd convenient (for memory allocation).  */
 157   bfd *abfd;
 158
 159   /* The lowest and highest addresses contained in this compilation
 160      unit as specified in the compilation unit header.  */
 161   struct arange arange;
 162
 163   /* The DW_AT_name attribute (for error messages).  */
 164   char *name;
 165
 166   /* The abbrev hash table.  */
 167   struct abbrev_info **abbrevs;
 168
 169   /* Note that an error was found by comp_unit_find_nearest_line.  */
 170   int error;
 171
 172   /* The DW_AT_comp_dir attribute.  */
 173   char *comp_dir;
 174
 175   /* TRUE if there is a line number table associated with this comp. unit.  */
 176   int stmtlist;
 177
 178   /* Pointer to the current comp_unit so that we can find a given entry
 179      by its reference.  */
 180   bfd_byte *info_ptr_unit;
 181
 182   /* The offset into .debug_line of the line number table.  */
 183   unsigned long line_offset;
 184
 185   /* Pointer to the first child die for the comp unit.  */
 186   bfd_byte *first_child_die_ptr;
 187
 188   /* The end of the comp unit.  */
 189   bfd_byte *end_ptr;
 190
 191   /* The decoded line number, NULL if not yet decoded.  */
 192   struct line_info_table *line_table;
 193
 194   /* A list of the functions found in this comp. unit.  */
 195   struct funcinfo *function_table;
 196
 197   /* A list of the variables found in this comp. unit.  */
 198   struct varinfo *variable_table;
 199
 200   /* Pointer to dwarf2_debug structure.  */
 201   struct dwarf2_debug *stash;
 202
 203   /* Address size for this unit - from unit header.  */
 204   unsigned char addr_size;
 205
 206   /* Offset size for this unit - from unit header.  */
 207   unsigned char offset_size;
 208
 209   /* Base address for this unit - from DW_AT_low_pc attribute of
 210      DW_TAG_compile_unit DIE */
 211   bfd_vma base_address;
 212 };
 213
 214 /* This data structure holds the information of an abbrev.  */
 215 struct abbrev_info
 216 {
 217   unsigned int number;          /* Number identifying abbrev.  */
 218   enum dwarf_tag tag;           /* DWARF tag.  */
 219   int has_children;             /* Boolean.  */
 220   unsigned int num_attrs;       /* Number of attributes.  */
 221   struct attr_abbrev *attrs;    /* An array of attribute descriptions.  */
 222   struct abbrev_info *next;     /* Next in chain.  */
 223 };
 224
 225 struct attr_abbrev
 226 {
 227   enum dwarf_attribute name;
 228   enum dwarf_form form;
 229 };
 230
 231 #ifndef ABBREV_HASH_SIZE
 232 #define ABBREV_HASH_SIZE 121
 233 #endif
 234 #ifndef ATTR_ALLOC_CHUNK
 235 #define ATTR_ALLOC_CHUNK 4
 236 #endif
 237
 238 /* VERBATIM
 239    The following function up to the END VERBATIM mark are
 240    copied directly from dwarf2read.c.  */
 241
 242 /* Read dwarf information from a buffer.  */
 243
 244 static unsigned int
 245 read_1_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
 246 {
 247   return bfd_get_8 (abfd, buf);
 248 }
 249
 250 static int
 251 read_1_signed_byte (bfd *abfd ATTRIBUTE_UNUSED, bfd_byte *buf)
 252 {
 253   return bfd_get_signed_8 (abfd, buf);
 254 }
 255
 256 static unsigned int
 257 read_2_bytes (bfd *abfd, bfd_byte *buf)
 258 {
 259   return bfd_get_16 (abfd, buf);
 260 }
 261
 262 static unsigned int
 263 read_4_bytes (bfd *abfd, bfd_byte *buf)
 264 {
 265   return bfd_get_32 (abfd, buf);
 266 }
 267
 268 static bfd_uint64_t
 269 read_8_bytes (bfd *abfd, bfd_byte *buf)
 270 {
 271   return bfd_get_64 (abfd, buf);
 272 }
 273
 274 static bfd_byte *
 275 read_n_bytes (bfd *abfd ATTRIBUTE_UNUSED,
 276               bfd_byte *buf,
 277               unsigned int size ATTRIBUTE_UNUSED)
 278 {
 279   /* If the size of a host char is 8 bits, we can return a pointer
 280      to the buffer, otherwise we have to copy the data to a buffer
 281      allocated on the temporary obstack.  */
 282   return buf;
 283 }
 284
 285 static char *
 286 read_string (bfd *abfd ATTRIBUTE_UNUSED,
 287              bfd_byte *buf,
 288              unsigned int *bytes_read_ptr)
 289 {
 290   /* Return a pointer to the embedded string.  */
 291   char *str = (char *) buf;
 292   if (*str == '\0')
 293     {
 294       *bytes_read_ptr = 1;
 295       return NULL;
 296     }
 297
 298   *bytes_read_ptr = strlen (str) + 1;
 299   return str;
 300 }
 301
 302 static char *
 303 read_indirect_string (struct comp_unit* unit,
 304                       bfd_byte *buf,
 305                       unsigned int *bytes_read_ptr)
 306 {
 307   bfd_uint64_t offset;
 308   struct dwarf2_debug *stash = unit->stash;
 309   char *str;
 310
 311   if (unit->offset_size == 4)
 312     offset = read_4_bytes (unit->abfd, buf);
 313   else
 314     offset = read_8_bytes (unit->abfd, buf);
 315   *bytes_read_ptr = unit->offset_size;
 316
 317   if (! stash->dwarf_str_buffer)
 318     {
 319       asection *msec;
 320       bfd *abfd = unit->abfd;
 321       bfd_size_type sz;
 322
 323       msec = bfd_get_section_by_name (abfd, ".debug_str");
 324       if (! msec)
 325         {
 326           (*_bfd_error_handler)
 327             (_("Dwarf Error: Can't find .debug_str section."));
 328           bfd_set_error (bfd_error_bad_value);
 329           return NULL;
 330         }
 331
 332       sz = msec->rawsize ? msec->rawsize : msec->size;
 333       stash->dwarf_str_size = sz;
 334       stash->dwarf_str_buffer = bfd_alloc (abfd, sz);
 335       if (! stash->dwarf_str_buffer)
 336         return NULL;
 337
 338       if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
 339                                       0, sz))
 340         return NULL;
 341     }
 342
 343   if (offset >= stash->dwarf_str_size)
 344     {
 345       (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
 346                              (unsigned long) offset, stash->dwarf_str_size);
 347       bfd_set_error (bfd_error_bad_value);
 348       return NULL;
 349     }
 350
 351   str = (char *) stash->dwarf_str_buffer + offset;
 352   if (*str == '\0')
 353     return NULL;
 354   return str;
 355 }
 356
 357 /* END VERBATIM */
 358
 359 static bfd_uint64_t
 360 read_address (struct comp_unit *unit, bfd_byte *buf)
 361 {
 362   int signed_vma = get_elf_backend_data (unit->abfd)->sign_extend_vma;
 363
 364   if (signed_vma)
 365     {
 366       switch (unit->addr_size)
 367         {
 368         case 8:
 369           return bfd_get_signed_64 (unit->abfd, buf);
 370         case 4:
 371           return bfd_get_signed_32 (unit->abfd, buf);
 372         case 2:
 373           return bfd_get_signed_16 (unit->abfd, buf);
 374         default:
 375           abort ();
 376         }
 377     }
 378   else
 379     {
 380       switch (unit->addr_size)
 381         {
 382         case 8:
 383           return bfd_get_64 (unit->abfd, buf);
 384         case 4:
 385           return bfd_get_32 (unit->abfd, buf);
 386         case 2:
 387           return bfd_get_16 (unit->abfd, buf);
 388         default:
 389           abort ();
 390         }
 391     }
 392 }
 393
 394 /* Lookup an abbrev_info structure in the abbrev hash table.  */
 395
 396 static struct abbrev_info *
 397 lookup_abbrev (unsigned int number, struct abbrev_info **abbrevs)
 398 {
 399   unsigned int hash_number;
 400   struct abbrev_info *abbrev;
 401
 402   hash_number = number % ABBREV_HASH_SIZE;
 403   abbrev = abbrevs[hash_number];
 404
 405   while (abbrev)
 406     {
 407       if (abbrev->number == number)
 408         return abbrev;
 409       else
 410         abbrev = abbrev->next;
 411     }
 412
 413   return NULL;
 414 }
 415
 416 /* In DWARF version 2, the description of the debugging information is
 417    stored in a separate .debug_abbrev section.  Before we read any
 418    dies from a section we read in all abbreviations and install them
 419    in a hash table.  */
 420
 421 static struct abbrev_info**
 422 read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash)
 423 {
 424   struct abbrev_info **abbrevs;
 425   bfd_byte *abbrev_ptr;
 426   struct abbrev_info *cur_abbrev;
 427   unsigned int abbrev_number, bytes_read, abbrev_name;
 428   unsigned int abbrev_form, hash_number;
 429   bfd_size_type amt;
 430
 431   if (! stash->dwarf_abbrev_buffer)
 432     {
 433       asection *msec;
 434
 435       msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
 436       if (! msec)
 437         {
 438           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
 439           bfd_set_error (bfd_error_bad_value);
 440           return 0;
 441         }
 442
 443       stash->dwarf_abbrev_size = msec->size;
 444       stash->dwarf_abbrev_buffer
 445         = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
 446                                                      stash->syms);
 447       if (! stash->dwarf_abbrev_buffer)
 448           return 0;
 449     }
 450
 451   if (offset >= stash->dwarf_abbrev_size)
 452     {
 453       (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."),
 454                              (unsigned long) offset, stash->dwarf_abbrev_size);
 455       bfd_set_error (bfd_error_bad_value);
 456       return 0;
 457     }
 458
 459   amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
 460   abbrevs = bfd_zalloc (abfd, amt);
 461
 462   abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
 463   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 464   abbrev_ptr += bytes_read;
 465
 466   /* Loop until we reach an abbrev number of 0.  */
 467   while (abbrev_number)
 468     {
 469       amt = sizeof (struct abbrev_info);
 470       cur_abbrev = bfd_zalloc (abfd, amt);
 471
 472       /* Read in abbrev header.  */
 473       cur_abbrev->number = abbrev_number;
 474       cur_abbrev->tag = (enum dwarf_tag)
 475         read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 476       abbrev_ptr += bytes_read;
 477       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
 478       abbrev_ptr += 1;
 479
 480       /* Now read in declarations.  */
 481       abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 482       abbrev_ptr += bytes_read;
 483       abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 484       abbrev_ptr += bytes_read;
 485
 486       while (abbrev_name)
 487         {
 488           if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
 489             {
 490               struct attr_abbrev *tmp;
 491
 492               amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
 493               amt *= sizeof (struct attr_abbrev);
 494               tmp = bfd_realloc (cur_abbrev->attrs, amt);
 495               if (tmp == NULL)
 496                 {
 497                   size_t i;
 498
 499                   for (i = 0; i < ABBREV_HASH_SIZE; i++)
 500                     {
 501                       struct abbrev_info *abbrev = abbrevs[i];
 502
 503                       while (abbrev)
 504                         {
 505                           free (abbrev->attrs);
 506                           abbrev = abbrev->next;
 507                         }
 508                     }
 509                   return NULL;
 510                 }
 511               cur_abbrev->attrs = tmp;
 512             }
 513
 514           cur_abbrev->attrs[cur_abbrev->num_attrs].name
 515             = (enum dwarf_attribute) abbrev_name;
 516           cur_abbrev->attrs[cur_abbrev->num_attrs++].form
 517             = (enum dwarf_form) abbrev_form;
 518           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 519           abbrev_ptr += bytes_read;
 520           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 521           abbrev_ptr += bytes_read;
 522         }
 523
 524       hash_number = abbrev_number % ABBREV_HASH_SIZE;
 525       cur_abbrev->next = abbrevs[hash_number];
 526       abbrevs[hash_number] = cur_abbrev;
 527
 528       /* Get next abbreviation.
 529          Under Irix6 the abbreviations for a compilation unit are not
 530          always properly terminated with an abbrev number of 0.
 531          Exit loop if we encounter an abbreviation which we have
 532          already read (which means we are about to read the abbreviations
 533          for the next compile unit) or if the end of the abbreviation
 534          table is reached.  */
 535       if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
 536           >= stash->dwarf_abbrev_size)
 537         break;
 538       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 539       abbrev_ptr += bytes_read;
 540       if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
 541         break;
 542     }
 543
 544   return abbrevs;
 545 }
 546
 547 /* Read an attribute value described by an attribute form.  */
 548
 549 static bfd_byte *
 550 read_attribute_value (struct attribute *attr,
 551                       unsigned form,
 552                       struct comp_unit *unit,
 553                       bfd_byte *info_ptr)
 554 {
 555   bfd *abfd = unit->abfd;
 556   unsigned int bytes_read;
 557   struct dwarf_block *blk;
 558   bfd_size_type amt;
 559
 560   attr->form = (enum dwarf_form) form;
 561
 562   switch (form)
 563     {
 564     case DW_FORM_addr:
 565       /* FIXME: DWARF3 draft says DW_FORM_ref_addr is offset_size.  */
 566     case DW_FORM_ref_addr:
 567       attr->u.val = read_address (unit, info_ptr);
 568       info_ptr += unit->addr_size;
 569       break;
 570     case DW_FORM_block2:
 571       amt = sizeof (struct dwarf_block);
 572       blk = bfd_alloc (abfd, amt);
 573       blk->size = read_2_bytes (abfd, info_ptr);
 574       info_ptr += 2;
 575       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 576       info_ptr += blk->size;
 577       attr->u.blk = blk;
 578       break;
 579     case DW_FORM_block4:
 580       amt = sizeof (struct dwarf_block);
 581       blk = bfd_alloc (abfd, amt);
 582       blk->size = read_4_bytes (abfd, info_ptr);
 583       info_ptr += 4;
 584       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 585       info_ptr += blk->size;
 586       attr->u.blk = blk;
 587       break;
 588     case DW_FORM_data2:
 589       attr->u.val = read_2_bytes (abfd, info_ptr);
 590       info_ptr += 2;
 591       break;
 592     case DW_FORM_data4:
 593       attr->u.val = read_4_bytes (abfd, info_ptr);
 594       info_ptr += 4;
 595       break;
 596     case DW_FORM_data8:
 597       attr->u.val = read_8_bytes (abfd, info_ptr);
 598       info_ptr += 8;
 599       break;
 600     case DW_FORM_string:
 601       attr->u.str = read_string (abfd, info_ptr, &bytes_read);
 602       info_ptr += bytes_read;
 603       break;
 604     case DW_FORM_strp:
 605       attr->u.str = read_indirect_string (unit, info_ptr, &bytes_read);
 606       info_ptr += bytes_read;
 607       break;
 608     case DW_FORM_block:
 609       amt = sizeof (struct dwarf_block);
 610       blk = bfd_alloc (abfd, amt);
 611       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 612       info_ptr += bytes_read;
 613       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 614       info_ptr += blk->size;
 615       attr->u.blk = blk;
 616       break;
 617     case DW_FORM_block1:
 618       amt = sizeof (struct dwarf_block);
 619       blk = bfd_alloc (abfd, amt);
 620       blk->size = read_1_byte (abfd, info_ptr);
 621       info_ptr += 1;
 622       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 623       info_ptr += blk->size;
 624       attr->u.blk = blk;
 625       break;
 626     case DW_FORM_data1:
 627       attr->u.val = read_1_byte (abfd, info_ptr);
 628       info_ptr += 1;
 629       break;
 630     case DW_FORM_flag:
 631       attr->u.val = read_1_byte (abfd, info_ptr);
 632       info_ptr += 1;
 633       break;
 634     case DW_FORM_sdata:
 635       attr->u.sval = read_signed_leb128 (abfd, info_ptr, &bytes_read);
 636       info_ptr += bytes_read;
 637       break;
 638     case DW_FORM_udata:
 639       attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 640       info_ptr += bytes_read;
 641       break;
 642     case DW_FORM_ref1:
 643       attr->u.val = read_1_byte (abfd, info_ptr);
 644       info_ptr += 1;
 645       break;
 646     case DW_FORM_ref2:
 647       attr->u.val = read_2_bytes (abfd, info_ptr);
 648       info_ptr += 2;
 649       break;
 650     case DW_FORM_ref4:
 651       attr->u.val = read_4_bytes (abfd, info_ptr);
 652       info_ptr += 4;
 653       break;
 654     case DW_FORM_ref8:
 655       attr->u.val = read_8_bytes (abfd, info_ptr);
 656       info_ptr += 8;
 657       break;
 658     case DW_FORM_ref_udata:
 659       attr->u.val = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 660       info_ptr += bytes_read;
 661       break;
 662     case DW_FORM_indirect:
 663       form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 664       info_ptr += bytes_read;
 665       info_ptr = read_attribute_value (attr, form, unit, info_ptr);
 666       break;
 667     default:
 668       (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
 669                              form);
 670       bfd_set_error (bfd_error_bad_value);
 671     }
 672   return info_ptr;
 673 }
 674
 675 /* Read an attribute described by an abbreviated attribute.  */
 676
 677 static bfd_byte *
 678 read_attribute (struct attribute *attr,
 679                 struct attr_abbrev *abbrev,
 680                 struct comp_unit *unit,
 681                 bfd_byte *info_ptr)
 682 {
 683   attr->name = abbrev->name;
 684   info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
 685   return info_ptr;
 686 }
 687
 688 /* Source line information table routines.  */
 689
 690 #define FILE_ALLOC_CHUNK 5
 691 #define DIR_ALLOC_CHUNK 5
 692
 693 struct line_info
 694 {
 695   struct line_info* prev_line;
 696   bfd_vma address;
 697   char *filename;
 698   unsigned int line;
 699   unsigned int column;
 700   int end_sequence;             /* End of (sequential) code sequence.  */
 701 };
 702
 703 struct fileinfo
 704 {
 705   char *name;
 706   unsigned int dir;
 707   unsigned int time;
 708   unsigned int size;
 709 };
 710
 711 struct line_info_table
 712 {
 713   bfd* abfd;
 714   unsigned int num_files;
 715   unsigned int num_dirs;
 716   char *comp_dir;
 717   char **dirs;
 718   struct fileinfo* files;
 719   struct line_info* last_line;  /* largest VMA */
 720   struct line_info* lcl_head;   /* local head; used in 'add_line_info' */
 721 };
 722
 723 /* Remember some information about each function.  If the function is
 724    inlined (DW_TAG_inlined_subroutine) it may have two additional
 725    attributes, DW_AT_call_file and DW_AT_call_line, which specify the
 726    source code location where this function was inlined. */
 727
 728 struct funcinfo
 729 {
 730   struct funcinfo *prev_func;           /* Pointer to previous function in list of all functions */
 731   struct funcinfo *caller_func;         /* Pointer to function one scope higher */
 732   char *caller_file;                    /* Source location file name where caller_func inlines this func */
 733   int caller_line;                      /* Source location line number where caller_func inlines this func */
 734   char *file;                           /* Source location file name */
 735   int line;                             /* Source location line number */
 736   int tag;
 737   char *name;
 738   struct arange arange;
 739   asection *sec;                        /* Where the symbol is defined */
 740 };
 741
 742 struct varinfo
 743 {
 744   /* Pointer to previous variable in list of all variables */
 745   struct varinfo *prev_var;
 746   /* Source location file name */
 747   char *file;
 748   /* Source location line number */
 749   int line;
 750   int tag;
 751   char *name;
 752   bfd_vma addr;
 753   /* Where the symbol is defined */
 754   asection *sec;
 755   /* Is this a stack variable? */
 756   unsigned int stack: 1;
 757 };
 758
 759 /* Return TRUE if NEW_LINE should sort after LINE.  */
 760
 761 static inline bfd_boolean
 762 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
 763 {
 764   return (new_line->address > line->address
 765           || (new_line->address == line->address
 766               && new_line->end_sequence < line->end_sequence));
 767 }
 768
 769
 770 /* Adds a new entry to the line_info list in the line_info_table, ensuring
 771    that the list is sorted.  Note that the line_info list is sorted from
 772    highest to lowest VMA (with possible duplicates); that is,
 773    line_info->prev_line always accesses an equal or smaller VMA.  */
 774
 775 static void
 776 add_line_info (struct line_info_table *table,
 777                bfd_vma address,
 778                char *filename,
 779                unsigned int line,
 780                unsigned int column,
 781                int end_sequence)
 782 {
 783   bfd_size_type amt = sizeof (struct line_info);
 784   struct line_info* info = bfd_alloc (table->abfd, amt);
 785
 786   /* Set member data of 'info'.  */
 787   info->address = address;
 788   info->line = line;
 789   info->column = column;
 790   info->end_sequence = end_sequence;
 791
 792   if (filename && filename[0])
 793     {
 794       info->filename = bfd_alloc (table->abfd, strlen (filename) + 1);
 795       if (info->filename)
 796         strcpy (info->filename, filename);
 797     }
 798   else
 799     info->filename = NULL;
 800
 801   /* Find the correct location for 'info'.  Normally we will receive
 802      new line_info data 1) in order and 2) with increasing VMAs.
 803      However some compilers break the rules (cf. decode_line_info) and
 804      so we include some heuristics for quickly finding the correct
 805      location for 'info'. In particular, these heuristics optimize for
 806      the common case in which the VMA sequence that we receive is a
 807      list of locally sorted VMAs such as
 808        p...z a...j  (where a < j < p < z)
 809
 810      Note: table->lcl_head is used to head an *actual* or *possible*
 811      sequence within the list (such as a...j) that is not directly
 812      headed by table->last_line
 813
 814      Note: we may receive duplicate entries from 'decode_line_info'.  */
 815
 816   if (!table->last_line
 817       || new_line_sorts_after (info, table->last_line))
 818     {
 819       /* Normal case: add 'info' to the beginning of the list */
 820       info->prev_line = table->last_line;
 821       table->last_line = info;
 822
 823       /* lcl_head: initialize to head a *possible* sequence at the end.  */
 824       if (!table->lcl_head)
 825         table->lcl_head = info;
 826     }
 827   else if (!new_line_sorts_after (info, table->lcl_head)
 828            && (!table->lcl_head->prev_line
 829                || new_line_sorts_after (info, table->lcl_head->prev_line)))
 830     {
 831       /* Abnormal but easy: lcl_head is the head of 'info'.  */
 832       info->prev_line = table->lcl_head->prev_line;
 833       table->lcl_head->prev_line = info;
 834     }
 835   else
 836     {
 837       /* Abnormal and hard: Neither 'last_line' nor 'lcl_head' are valid
 838          heads for 'info'.  Reset 'lcl_head'.  */
 839       struct line_info* li2 = table->last_line; /* always non-NULL */
 840       struct line_info* li1 = li2->prev_line;
 841
 842       while (li1)
 843         {
 844           if (!new_line_sorts_after (info, li2)
 845               && new_line_sorts_after (info, li1))
 846             break;
 847
 848           li2 = li1; /* always non-NULL */
 849           li1 = li1->prev_line;
 850         }
 851       table->lcl_head = li2;
 852       info->prev_line = table->lcl_head->prev_line;
 853       table->lcl_head->prev_line = info;
 854     }
 855 }
 856
 857 /* Extract a fully qualified filename from a line info table.
 858    The returned string has been malloc'ed and it is the caller's
 859    responsibility to free it.  */
 860
 861 static char *
 862 concat_filename (struct line_info_table *table, unsigned int file)
 863 {
 864   char *filename;
 865
 866   if (file - 1 >= table->num_files)
 867     {
 868       /* FILE == 0 means unknown.  */
 869       if (file)
 870         (*_bfd_error_handler)
 871           (_("Dwarf Error: mangled line number section (bad file number)."));
 872       return strdup ("<unknown>");
 873     }
 874
 875   filename = table->files[file - 1].name;
 876
 877   if (! IS_ABSOLUTE_PATH (filename))
 878     {
 879       char *dirname = (table->files[file - 1].dir
 880                        ? table->dirs[table->files[file - 1].dir - 1]
 881                        : table->comp_dir);
 882
 883       /* Not all tools set DW_AT_comp_dir, so dirname may be unknown.
 884          The best we can do is return the filename part.  */
 885       if (dirname != NULL)
 886         {
 887           unsigned int len = strlen (dirname) + strlen (filename) + 2;
 888           char * name;
 889
 890           name = bfd_malloc (len);
 891           if (name)
 892             sprintf (name, "%s/%s", dirname, filename);
 893           return name;
 894         }
 895     }
 896
 897   return strdup (filename);
 898 }
 899
 900 static void
 901 arange_add (bfd *abfd, struct arange *first_arange, bfd_vma low_pc, bfd_vma high_pc)
 902 {
 903   struct arange *arange;
 904
 905   /* If the first arange is empty, use it. */
 906   if (first_arange->high == 0)
 907     {
 908       first_arange->low = low_pc;
 909       first_arange->high = high_pc;
 910       return;
 911     }
 912
 913   /* Next see if we can cheaply extend an existing range.  */
 914   arange = first_arange;
 915   do
 916     {
 917       if (low_pc == arange->high)
 918         {
 919           arange->high = high_pc;
 920           return;
 921         }
 922       if (high_pc == arange->low)
 923         {
 924           arange->low = low_pc;
 925           return;
 926         }
 927       arange = arange->next;
 928     }
 929   while (arange);
 930
 931   /* Need to allocate a new arange and insert it into the arange list.
 932      Order isn't significant, so just insert after the first arange. */
 933   arange = bfd_zalloc (abfd, sizeof (*arange));
 934   arange->low = low_pc;
 935   arange->high = high_pc;
 936   arange->next = first_arange->next;
 937   first_arange->next = arange;
 938 }
 939
 940 /* Decode the line number information for UNIT.  */
 941
 942 static struct line_info_table*
 943 decode_line_info (struct comp_unit *unit, struct dwarf2_debug *stash)
 944 {
 945   bfd *abfd = unit->abfd;
 946   struct line_info_table* table;
 947   bfd_byte *line_ptr;
 948   bfd_byte *line_end;
 949   struct line_head lh;
 950   unsigned int i, bytes_read, offset_size;
 951   char *cur_file, *cur_dir;
 952   unsigned char op_code, extended_op, adj_opcode;
 953   bfd_size_type amt;
 954
 955   if (! stash->dwarf_line_buffer)
 956     {
 957       asection *msec;
 958
 959       msec = bfd_get_section_by_name (abfd, ".debug_line");
 960       if (! msec)
 961         {
 962           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
 963           bfd_set_error (bfd_error_bad_value);
 964           return 0;
 965         }
 966
 967       stash->dwarf_line_size = msec->size;
 968       stash->dwarf_line_buffer
 969         = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
 970                                                      stash->syms);
 971       if (! stash->dwarf_line_buffer)
 972         return 0;
 973     }
 974
 975   /* It is possible to get a bad value for the line_offset.  Validate
 976      it here so that we won't get a segfault below.  */
 977   if (unit->line_offset >= stash->dwarf_line_size)
 978     {
 979       (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
 980                              unit->line_offset, stash->dwarf_line_size);
 981       bfd_set_error (bfd_error_bad_value);
 982       return 0;
 983     }
 984
 985   amt = sizeof (struct line_info_table);
 986   table = bfd_alloc (abfd, amt);
 987   table->abfd = abfd;
 988   table->comp_dir = unit->comp_dir;
 989
 990   table->num_files = 0;
 991   table->files = NULL;
 992
 993   table->num_dirs = 0;
 994   table->dirs = NULL;
 995
 996   table->files = NULL;
 997   table->last_line = NULL;
 998   table->lcl_head = NULL;
 999
1000   line_ptr = stash->dwarf_line_buffer + unit->line_offset;
1001
1002   /* Read in the prologue.  */
1003   lh.total_length = read_4_bytes (abfd, line_ptr);
1004   line_ptr += 4;
1005   offset_size = 4;
1006   if (lh.total_length == 0xffffffff)
1007     {
1008       lh.total_length = read_8_bytes (abfd, line_ptr);
1009       line_ptr += 8;
1010       offset_size = 8;
1011     }
1012   else if (lh.total_length == 0 && unit->addr_size == 8)
1013     {
1014       /* Handle (non-standard) 64-bit DWARF2 formats.  */
1015       lh.total_length = read_4_bytes (abfd, line_ptr);
1016       line_ptr += 4;
1017       offset_size = 8;
1018     }
1019   line_end = line_ptr + lh.total_length;
1020   lh.version = read_2_bytes (abfd, line_ptr);
1021   line_ptr += 2;
1022   if (offset_size == 4)
1023     lh.prologue_length = read_4_bytes (abfd, line_ptr);
1024   else
1025     lh.prologue_length = read_8_bytes (abfd, line_ptr);
1026   line_ptr += offset_size;
1027   lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1028   line_ptr += 1;
1029   lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1030   line_ptr += 1;
1031   lh.line_base = read_1_signed_byte (abfd, line_ptr);
1032   line_ptr += 1;
1033   lh.line_range = read_1_byte (abfd, line_ptr);
1034   line_ptr += 1;
1035   lh.opcode_base = read_1_byte (abfd, line_ptr);
1036   line_ptr += 1;
1037   amt = lh.opcode_base * sizeof (unsigned char);
1038   lh.standard_opcode_lengths = bfd_alloc (abfd, amt);
1039
1040   lh.standard_opcode_lengths[0] = 1;
1041
1042   for (i = 1; i < lh.opcode_base; ++i)
1043     {
1044       lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1045       line_ptr += 1;
1046     }
1047
1048   /* Read directory table.  */
1049   while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1050     {
1051       line_ptr += bytes_read;
1052
1053       if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1054         {
1055           char **tmp;
1056
1057           amt = table->num_dirs + DIR_ALLOC_CHUNK;
1058           amt *= sizeof (char *);
1059
1060           tmp = bfd_realloc (table->dirs, amt);
1061           if (tmp == NULL)
1062             {
1063               free (table->dirs);
1064               return NULL;
1065             }
1066           table->dirs = tmp;
1067         }
1068
1069       table->dirs[table->num_dirs++] = cur_dir;
1070     }
1071
1072   line_ptr += bytes_read;
1073
1074   /* Read file name table.  */
1075   while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1076     {
1077       line_ptr += bytes_read;
1078
1079       if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1080         {
1081           struct fileinfo *tmp;
1082
1083           amt = table->num_files + FILE_ALLOC_CHUNK;
1084           amt *= sizeof (struct fileinfo);
1085
1086           tmp = bfd_realloc (table->files, amt);
1087           if (tmp == NULL)
1088             {
1089               free (table->files);
1090               free (table->dirs);
1091               return NULL;
1092             }
1093           table->files = tmp;
1094         }
1095
1096       table->files[table->num_files].name = cur_file;
1097       table->files[table->num_files].dir =
1098         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1099       line_ptr += bytes_read;
1100       table->files[table->num_files].time =
1101         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1102       line_ptr += bytes_read;
1103       table->files[table->num_files].size =
1104         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1105       line_ptr += bytes_read;
1106       table->num_files++;
1107     }
1108
1109   line_ptr += bytes_read;
1110
1111   /* Read the statement sequences until there's nothing left.  */
1112   while (line_ptr < line_end)
1113     {
1114       /* State machine registers.  */
1115       bfd_vma address = 0;
1116       char * filename = table->num_files ? concat_filename (table, 1) : NULL;
1117       unsigned int line = 1;
1118       unsigned int column = 0;
1119       int is_stmt = lh.default_is_stmt;
1120       int basic_block = 0;
1121       int end_sequence = 0;
1122       /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1123          compilers generate address sequences that are wildly out of
1124          order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1125          for ia64-Linux).  Thus, to determine the low and high
1126          address, we must compare on every DW_LNS_copy, etc.  */
1127       bfd_vma low_pc  = (bfd_vma) -1;
1128       bfd_vma high_pc = 0;
1129
1130       /* Decode the table.  */
1131       while (! end_sequence)
1132         {
1133           op_code = read_1_byte (abfd, line_ptr);
1134           line_ptr += 1;
1135
1136           if (op_code >= lh.opcode_base)
1137             {
1138               /* Special operand.  */
1139               adj_opcode = op_code - lh.opcode_base;
1140               address += (adj_opcode / lh.line_range)
1141                 * lh.minimum_instruction_length;
1142               line += lh.line_base + (adj_opcode % lh.line_range);
1143               /* Append row to matrix using current values.  */
1144               add_line_info (table, address, filename, line, column, 0);
1145               basic_block = 1;
1146               if (address < low_pc)
1147                 low_pc = address;
1148               if (address > high_pc)
1149                 high_pc = address;
1150             }
1151           else switch (op_code)
1152             {
1153             case DW_LNS_extended_op:
1154               /* Ignore length.  */
1155               line_ptr += 1;
1156               extended_op = read_1_byte (abfd, line_ptr);
1157               line_ptr += 1;
1158
1159               switch (extended_op)
1160                 {
1161                 case DW_LNE_end_sequence:
1162                   end_sequence = 1;
1163                   add_line_info (table, address, filename, line, column,
1164                                  end_sequence);
1165                   if (address < low_pc)
1166                     low_pc = address;
1167                   if (address > high_pc)
1168                     high_pc = address;
1169                   arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
1170                   break;
1171                 case DW_LNE_set_address:
1172                   address = read_address (unit, line_ptr);
1173                   line_ptr += unit->addr_size;
1174                   break;
1175                 case DW_LNE_define_file:
1176                   cur_file = read_string (abfd, line_ptr, &bytes_read);
1177                   line_ptr += bytes_read;
1178                   if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1179                     {
1180                       struct fileinfo *tmp;
1181
1182                       amt = table->num_files + FILE_ALLOC_CHUNK;
1183                       amt *= sizeof (struct fileinfo);
1184                       tmp = bfd_realloc (table->files, amt);
1185                       if (tmp == NULL)
1186                         {
1187                           free (table->files);
1188                           free (table->dirs);
1189                           free (filename);
1190                           return NULL;
1191                         }
1192                       table->files = tmp;
1193                     }
1194                   table->files[table->num_files].name = cur_file;
1195                   table->files[table->num_files].dir =
1196                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1197                   line_ptr += bytes_read;
1198                   table->files[table->num_files].time =
1199                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1200                   line_ptr += bytes_read;
1201                   table->files[table->num_files].size =
1202                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1203                   line_ptr += bytes_read;
1204                   table->num_files++;
1205                   break;
1206                 default:
1207                   (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1208                   bfd_set_error (bfd_error_bad_value);
1209                   free (filename);
1210                   free (table->files);
1211                   free (table->dirs);
1212                   return NULL;
1213                 }
1214               break;
1215             case DW_LNS_copy:
1216               add_line_info (table, address, filename, line, column, 0);
1217               basic_block = 0;
1218               if (address < low_pc)
1219                 low_pc = address;
1220               if (address > high_pc)
1221                 high_pc = address;
1222               break;
1223             case DW_LNS_advance_pc:
1224               address += lh.minimum_instruction_length
1225                 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1226               line_ptr += bytes_read;
1227               break;
1228             case DW_LNS_advance_line:
1229               line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1230               line_ptr += bytes_read;
1231               break;
1232             case DW_LNS_set_file:
1233               {
1234                 unsigned int file;
1235
1236                 /* The file and directory tables are 0
1237                    based, the references are 1 based.  */
1238                 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1239                 line_ptr += bytes_read;
1240                 if (filename)
1241                   free (filename);
1242                 filename = concat_filename (table, file);
1243                 break;
1244               }
1245             case DW_LNS_set_column:
1246               column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1247               line_ptr += bytes_read;
1248               break;
1249             case DW_LNS_negate_stmt:
1250               is_stmt = (!is_stmt);
1251               break;
1252             case DW_LNS_set_basic_block:
1253               basic_block = 1;
1254               break;
1255             case DW_LNS_const_add_pc:
1256               address += lh.minimum_instruction_length
1257                       * ((255 - lh.opcode_base) / lh.line_range);
1258               break;
1259             case DW_LNS_fixed_advance_pc:
1260               address += read_2_bytes (abfd, line_ptr);
1261               line_ptr += 2;
1262               break;
1263             default:
1264               {
1265                 int i;
1266
1267                 /* Unknown standard opcode, ignore it.  */
1268                 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1269                   {
1270                     (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1271                     line_ptr += bytes_read;
1272                   }
1273               }
1274             }
1275         }
1276
1277       if (filename)
1278         free (filename);
1279     }
1280
1281   return table;
1282 }
1283
1284 /* If ADDR is within TABLE set the output parameters and return TRUE,
1285    otherwise return FALSE.  The output parameters, FILENAME_PTR and
1286    LINENUMBER_PTR, are pointers to the objects to be filled in.  */
1287
1288 static bfd_boolean
1289 lookup_address_in_line_info_table (struct line_info_table *table,
1290                                    bfd_vma addr,
1291                                    struct funcinfo *function,
1292                                    const char **filename_ptr,
1293                                    unsigned int *linenumber_ptr)
1294 {
1295   /* Note: table->last_line should be a descendingly sorted list. */
1296   struct line_info* next_line = table->last_line;
1297   struct line_info* each_line = NULL;
1298   *filename_ptr = NULL;
1299
1300   if (!next_line)
1301     return FALSE;
1302
1303   each_line = next_line->prev_line;
1304
1305   /* Check for large addresses */
1306   if (addr > next_line->address)
1307     each_line = NULL; /* ensure we skip over the normal case */
1308
1309   /* Normal case: search the list; save  */
1310   while (each_line && next_line)
1311     {
1312       /* If we have an address match, save this info.  This allows us
1313          to return as good as results as possible for strange debugging
1314          info.  */
1315       bfd_boolean addr_match = FALSE;
1316       if (each_line->address <= addr && addr < next_line->address)
1317         {
1318           addr_match = TRUE;
1319
1320           /* If this line appears to span functions, and addr is in the
1321              later function, return the first line of that function instead
1322              of the last line of the earlier one.  This check is for GCC
1323              2.95, which emits the first line number for a function late.  */
1324
1325           if (function != NULL)
1326             {
1327               bfd_vma lowest_pc;
1328               struct arange *arange;
1329
1330               /* Find the lowest address in the function's range list */
1331               lowest_pc = function->arange.low;
1332               for (arange = &function->arange;
1333                    arange;
1334                    arange = arange->next)
1335                 {
1336                   if (function->arange.low < lowest_pc)
1337                     lowest_pc = function->arange.low;
1338                 }
1339               /* Check for spanning function and set outgoing line info */
1340               if (addr >= lowest_pc
1341                   && each_line->address < lowest_pc
1342                   && next_line->address > lowest_pc)
1343                 {
1344                   *filename_ptr = next_line->filename;
1345                   *linenumber_ptr = next_line->line;
1346                 }
1347               else
1348                 {
1349                   *filename_ptr = each_line->filename;
1350                   *linenumber_ptr = each_line->line;
1351                 }
1352             }
1353           else
1354             {
1355               *filename_ptr = each_line->filename;
1356               *linenumber_ptr = each_line->line;
1357             }
1358         }
1359
1360       if (addr_match && !each_line->end_sequence)
1361         return TRUE; /* we have definitely found what we want */
1362
1363       next_line = each_line;
1364       each_line = each_line->prev_line;
1365     }
1366
1367   /* At this point each_line is NULL but next_line is not.  If we found
1368      a candidate end-of-sequence point in the loop above, we can return
1369      that (compatibility with a bug in the Intel compiler); otherwise,
1370      assuming that we found the containing function for this address in
1371      this compilation unit, return the first line we have a number for
1372      (compatibility with GCC 2.95).  */
1373   if (*filename_ptr == NULL && function != NULL)
1374     {
1375       *filename_ptr = next_line->filename;
1376       *linenumber_ptr = next_line->line;
1377       return TRUE;
1378     }
1379
1380   return FALSE;
1381 }
1382
1383 /* Read in the .debug_ranges section for future reference */
1384
1385 static bfd_boolean
1386 read_debug_ranges (struct comp_unit *unit)
1387 {
1388   struct dwarf2_debug *stash = unit->stash;
1389   if (! stash->dwarf_ranges_buffer)
1390     {
1391       bfd *abfd = unit->abfd;
1392       asection *msec;
1393
1394       msec = bfd_get_section_by_name (abfd, ".debug_ranges");
1395       if (! msec)
1396         {
1397           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_ranges section."));
1398           bfd_set_error (bfd_error_bad_value);
1399           return FALSE;
1400         }
1401
1402       stash->dwarf_ranges_size = msec->size;
1403       stash->dwarf_ranges_buffer
1404         = bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
1405                                                      stash->syms);
1406       if (! stash->dwarf_ranges_buffer)
1407         return FALSE;
1408     }
1409   return TRUE;
1410 }
1411
1412 /* Function table functions.  */
1413
1414 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return TRUE.
1415    Note that we need to find the function that has the smallest
1416    range that contains ADDR, to handle inlined functions without
1417    depending upon them being ordered in TABLE by increasing range. */
1418
1419 static bfd_boolean
1420 lookup_address_in_function_table (struct comp_unit *unit,
1421                                   bfd_vma addr,
1422                                   struct funcinfo **function_ptr,
1423                                   const char **functionname_ptr)
1424 {
1425   struct funcinfo* each_func;
1426   struct funcinfo* best_fit = NULL;
1427   struct arange *arange;
1428
1429   for (each_func = unit->function_table;
1430        each_func;
1431        each_func = each_func->prev_func)
1432     {
1433       for (arange = &each_func->arange;
1434            arange;
1435            arange = arange->next)
1436         {
1437           if (addr >= arange->low && addr < arange->high)
1438             {
1439               if (!best_fit ||
1440                   ((arange->high - arange->low) < (best_fit->arange.high - best_fit->arange.low)))
1441                 best_fit = each_func;
1442             }
1443         }
1444     }
1445
1446   if (best_fit)
1447     {
1448       *functionname_ptr = best_fit->name;
1449       *function_ptr = best_fit;
1450       return TRUE;
1451     }
1452   else
1453     {
1454       return FALSE;
1455     }
1456 }
1457
1458 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
1459    and LINENUMBER_PTR, and return TRUE.  */
1460
1461 static bfd_boolean
1462 lookup_symbol_in_function_table (struct comp_unit *unit,
1463                                  asymbol *sym,
1464                                  bfd_vma addr,
1465                                  const char **filename_ptr,
1466                                  unsigned int *linenumber_ptr)
1467 {
1468   struct funcinfo* each_func;
1469   struct funcinfo* best_fit = NULL;
1470   struct arange *arange;
1471   const char *name = bfd_asymbol_name (sym);
1472   asection *sec = bfd_get_section (sym);
1473
1474   for (each_func = unit->function_table;
1475        each_func;
1476        each_func = each_func->prev_func)
1477     {
1478       for (arange = &each_func->arange;
1479            arange;
1480            arange = arange->next)
1481         {
1482           if ((!each_func->sec || each_func->sec == sec)
1483               && addr >= arange->low
1484               && addr < arange->high
1485               && each_func->name
1486               && strcmp (name, each_func->name) == 0
1487               && (!best_fit
1488                   || ((arange->high - arange->low)
1489                       < (best_fit->arange.high - best_fit->arange.low))))
1490             best_fit = each_func;
1491         }
1492     }
1493
1494   if (best_fit)
1495     {
1496       best_fit->sec = sec;
1497       *filename_ptr = best_fit->file;
1498       *linenumber_ptr = best_fit->line;
1499       return TRUE;
1500     }
1501   else
1502     return FALSE;
1503 }
1504
1505 /* Variable table functions.  */
1506
1507 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
1508    LINENUMBER_PTR, and return TRUE.  */
1509
1510 static bfd_boolean
1511 lookup_symbol_in_variable_table (struct comp_unit *unit,
1512                                  asymbol *sym,
1513                                  bfd_vma addr,
1514                                  const char **filename_ptr,
1515                                  unsigned int *linenumber_ptr)
1516 {
1517   const char *name = bfd_asymbol_name (sym);
1518   asection *sec = bfd_get_section (sym);
1519   struct varinfo* each;
1520
1521   for (each = unit->variable_table; each; each = each->prev_var)
1522     if (each->stack == 0
1523         && each->file != NULL
1524         && each->name != NULL
1525         && each->addr == addr
1526         && (!each->sec || each->sec == sec)
1527         && strcmp (name, each->name) == 0)
1528       break;
1529
1530   if (each)
1531     {
1532       each->sec = sec;
1533       *filename_ptr = each->file;
1534       *linenumber_ptr = each->line;
1535       return TRUE;
1536     }
1537   else
1538     return FALSE;
1539 }
1540
1541 static char *
1542 find_abstract_instance_name (struct comp_unit *unit, bfd_uint64_t die_ref)
1543 {
1544   bfd *abfd = unit->abfd;
1545   bfd_byte *info_ptr;
1546   unsigned int abbrev_number, bytes_read, i;
1547   struct abbrev_info *abbrev;
1548   struct attribute attr;
1549   char *name = 0;
1550
1551   info_ptr = unit->info_ptr_unit + die_ref;
1552   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1553   info_ptr += bytes_read;
1554
1555   if (abbrev_number)
1556     {
1557       abbrev = lookup_abbrev (abbrev_number, unit->abbrevs);
1558       if (! abbrev)
1559         {
1560           (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1561                                  abbrev_number);
1562           bfd_set_error (bfd_error_bad_value);
1563         }
1564       else
1565         {
1566           for (i = 0; i < abbrev->num_attrs; ++i)
1567             {
1568               info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1569               switch (attr.name)
1570                 {
1571                 case DW_AT_name:
1572                   /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
1573                   if (name == NULL)
1574                     name = attr.u.str;
1575                   break;
1576                 case DW_AT_specification:
1577                   name = find_abstract_instance_name (unit, attr.u.val);
1578                   break;
1579                 case DW_AT_MIPS_linkage_name:
1580                   name = attr.u.str;
1581                   break;
1582                 default:
1583                   break;
1584                 }
1585             }
1586         }
1587     }
1588   return (name);
1589 }
1590
1591 static void
1592 read_rangelist (struct comp_unit *unit, struct arange *arange, bfd_uint64_t offset)
1593 {
1594   bfd_byte *ranges_ptr;
1595   bfd_vma base_address = unit->base_address;
1596
1597   if (! unit->stash->dwarf_ranges_buffer)
1598     {
1599       if (! read_debug_ranges (unit))
1600         return;
1601     }
1602   ranges_ptr = unit->stash->dwarf_ranges_buffer + offset;
1603
1604   for (;;)
1605     {
1606       bfd_vma low_pc;
1607       bfd_vma high_pc;
1608
1609       if (unit->addr_size == 4)
1610         {
1611           low_pc = read_4_bytes (unit->abfd, ranges_ptr);
1612           ranges_ptr += 4;
1613           high_pc = read_4_bytes (unit->abfd, ranges_ptr);
1614           ranges_ptr += 4;
1615         }
1616       else
1617         {
1618           low_pc = read_8_bytes (unit->abfd, ranges_ptr);
1619           ranges_ptr += 8;
1620           high_pc = read_8_bytes (unit->abfd, ranges_ptr);
1621           ranges_ptr += 8;
1622         }
1623       if (low_pc == 0 && high_pc == 0)
1624         break;
1625       if (low_pc == -1UL && high_pc != -1UL)
1626         base_address = high_pc;
1627       else
1628         arange_add (unit->abfd, arange, base_address + low_pc, base_address + high_pc);
1629     }
1630 }
1631
1632 /* DWARF2 Compilation unit functions.  */
1633
1634 /* Scan over each die in a comp. unit looking for functions to add
1635    to the function table and variables to the variable table.  */
1636
1637 static bfd_boolean
1638 scan_unit_for_symbols (struct comp_unit *unit)
1639 {
1640   bfd *abfd = unit->abfd;
1641   bfd_byte *info_ptr = unit->first_child_die_ptr;
1642   int nesting_level = 1;
1643   struct funcinfo **nested_funcs;
1644   int nested_funcs_size;
1645
1646   /* Maintain a stack of in-scope functions and inlined functions, which we
1647      can use to set the caller_func field.  */
1648   nested_funcs_size = 32;
1649   nested_funcs = bfd_malloc (nested_funcs_size * sizeof (struct funcinfo *));
1650   if (nested_funcs == NULL)
1651     return FALSE;
1652   nested_funcs[nesting_level] = 0;
1653
1654   while (nesting_level)
1655     {
1656       unsigned int abbrev_number, bytes_read, i;
1657       struct abbrev_info *abbrev;
1658       struct attribute attr;
1659       struct funcinfo *func;
1660       struct varinfo *var;
1661       bfd_vma low_pc = 0;
1662       bfd_vma high_pc = 0;
1663
1664       abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1665       info_ptr += bytes_read;
1666
1667       if (! abbrev_number)
1668         {
1669           nesting_level--;
1670           continue;
1671         }
1672
1673       abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1674       if (! abbrev)
1675         {
1676           (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1677                              abbrev_number);
1678           bfd_set_error (bfd_error_bad_value);
1679           free (nested_funcs);
1680           return FALSE;
1681         }
1682
1683       var = NULL;
1684       if (abbrev->tag == DW_TAG_subprogram
1685           || abbrev->tag == DW_TAG_entry_point
1686           || abbrev->tag == DW_TAG_inlined_subroutine)
1687         {
1688           bfd_size_type amt = sizeof (struct funcinfo);
1689           func = bfd_zalloc (abfd, amt);
1690           func->tag = abbrev->tag;
1691           func->prev_func = unit->function_table;
1692           unit->function_table = func;
1693
1694           if (func->tag == DW_TAG_inlined_subroutine)
1695             for (i = nesting_level - 1; i >= 1; i--)
1696               if (nested_funcs[i])
1697                 {
1698                   func->caller_func = nested_funcs[i];
1699                   break;
1700                 }
1701           nested_funcs[nesting_level] = func;
1702         }
1703       else
1704         {
1705           func = NULL;
1706           if (abbrev->tag == DW_TAG_variable)
1707             {
1708               bfd_size_type amt = sizeof (struct varinfo);
1709               var = bfd_zalloc (abfd, amt);
1710               var->tag = abbrev->tag;
1711               var->stack = 1;
1712               var->prev_var = unit->variable_table;
1713               unit->variable_table = var;
1714             }
1715
1716           /* No inline function in scope at this nesting level.  */
1717           nested_funcs[nesting_level] = 0;
1718         }
1719
1720       for (i = 0; i < abbrev->num_attrs; ++i)
1721         {
1722           info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1723
1724           if (func)
1725             {
1726               switch (attr.name)
1727                 {
1728                 case DW_AT_call_file:
1729                   func->caller_file = concat_filename (unit->line_table, attr.u.val);
1730                   break;
1731
1732                 case DW_AT_call_line:
1733                   func->caller_line = attr.u.val;
1734                   break;
1735
1736                 case DW_AT_abstract_origin:
1737                   func->name = find_abstract_instance_name (unit, attr.u.val);
1738                   break;
1739
1740                 case DW_AT_name:
1741                   /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
1742                   if (func->name == NULL)
1743                     func->name = attr.u.str;
1744                   break;
1745
1746                 case DW_AT_MIPS_linkage_name:
1747                   func->name = attr.u.str;
1748                   break;
1749
1750                 case DW_AT_low_pc:
1751                   low_pc = attr.u.val;
1752                   break;
1753
1754                 case DW_AT_high_pc:
1755                   high_pc = attr.u.val;
1756                   break;
1757
1758                 case DW_AT_ranges:
1759                   read_rangelist (unit, &func->arange, attr.u.val);
1760                   break;
1761
1762                 case DW_AT_decl_file:
1763                   func->file = concat_filename (unit->line_table,
1764                                                 attr.u.val);
1765                   break;
1766
1767                 case DW_AT_decl_line:
1768                   func->line = attr.u.val;
1769                   break;
1770
1771                 default:
1772                   break;
1773                 }
1774             }
1775           else if (var)
1776             {
1777               switch (attr.name)
1778                 {
1779                 case DW_AT_name:
1780                   var->name = attr.u.str;
1781                   break;
1782
1783                 case DW_AT_decl_file:
1784                   var->file = concat_filename (unit->line_table,
1785                                                attr.u.val);
1786                   break;
1787
1788                 case DW_AT_decl_line:
1789                   var->line = attr.u.val;
1790                   break;
1791
1792                 case DW_AT_external:
1793                   if (attr.u.val != 0)
1794                     var->stack = 0;
1795                   break;
1796
1797                 case DW_AT_location:
1798                   switch (attr.form)
1799                     {
1800                     case DW_FORM_block:
1801                     case DW_FORM_block1:
1802                     case DW_FORM_block2:
1803                     case DW_FORM_block4:
1804                       if (*attr.u.blk->data == DW_OP_addr)
1805                         {
1806                           var->stack = 0;
1807
1808                           /* Verify that DW_OP_addr is the only opcode in the
1809                              location, in which case the block size will be 1
1810                              plus the address size.  */
1811                           /* ??? For TLS variables, gcc can emit
1812                              DW_OP_addr <addr> DW_OP_GNU_push_tls_address
1813                              which we don't handle here yet.  */
1814                           if (attr.u.blk->size == unit->addr_size + 1U)
1815                             var->addr = bfd_get (unit->addr_size * 8,
1816                                                  unit->abfd,
1817                                                  attr.u.blk->data + 1);
1818                         }
1819                       break;
1820
1821                     default:
1822                       break;
1823                     }
1824                   break;
1825
1826                 default:
1827                   break;
1828                 }
1829             }
1830         }
1831
1832       if (func && high_pc != 0)
1833         {
1834           arange_add (unit->abfd, &func->arange, low_pc, high_pc);
1835         }
1836
1837       if (abbrev->has_children)
1838         {
1839           nesting_level++;
1840
1841           if (nesting_level >= nested_funcs_size)
1842             {
1843               struct funcinfo **tmp;
1844
1845               nested_funcs_size *= 2;
1846               tmp = bfd_realloc (nested_funcs,
1847                                  (nested_funcs_size
1848                                   * sizeof (struct funcinfo *)));
1849               if (tmp == NULL)
1850                 {
1851                   free (nested_funcs);
1852                   return FALSE;
1853                 }
1854               nested_funcs = tmp;
1855             }
1856           nested_funcs[nesting_level] = 0;
1857         }
1858     }
1859
1860   free (nested_funcs);
1861   return TRUE;
1862 }
1863
1864 /* Parse a DWARF2 compilation unit starting at INFO_PTR.  This
1865    includes the compilation unit header that proceeds the DIE's, but
1866    does not include the length field that precedes each compilation
1867    unit header.  END_PTR points one past the end of this comp unit.
1868    OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1869
1870    This routine does not read the whole compilation unit; only enough
1871    to get to the line number information for the compilation unit.  */
1872
1873 static struct comp_unit *
1874 parse_comp_unit (bfd *abfd,
1875                  struct dwarf2_debug *stash,
1876                  bfd_vma unit_length,
1877                  bfd_byte *info_ptr_unit,
1878                  unsigned int offset_size)
1879 {
1880   struct comp_unit* unit;
1881   unsigned int version;
1882   bfd_uint64_t abbrev_offset = 0;
1883   unsigned int addr_size;
1884   struct abbrev_info** abbrevs;
1885   unsigned int abbrev_number, bytes_read, i;
1886   struct abbrev_info *abbrev;
1887   struct attribute attr;
1888   bfd_byte *info_ptr = stash->info_ptr;
1889   bfd_byte *end_ptr = info_ptr + unit_length;
1890   bfd_size_type amt;
1891   bfd_vma low_pc = 0;
1892   bfd_vma high_pc = 0;
1893
1894   version = read_2_bytes (abfd, info_ptr);
1895   info_ptr += 2;
1896   BFD_ASSERT (offset_size == 4 || offset_size == 8);
1897   if (offset_size == 4)
1898     abbrev_offset = read_4_bytes (abfd, info_ptr);
1899   else
1900     abbrev_offset = read_8_bytes (abfd, info_ptr);
1901   info_ptr += offset_size;
1902   addr_size = read_1_byte (abfd, info_ptr);
1903   info_ptr += 1;
1904
1905   if (version != 2)
1906     {
1907       (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
1908       bfd_set_error (bfd_error_bad_value);
1909       return 0;
1910     }
1911
1912   if (addr_size > sizeof (bfd_vma))
1913     {
1914       (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1915                          addr_size,
1916                          (unsigned int) sizeof (bfd_vma));
1917       bfd_set_error (bfd_error_bad_value);
1918       return 0;
1919     }
1920
1921   if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1922     {
1923       (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
1924       bfd_set_error (bfd_error_bad_value);
1925       return 0;
1926     }
1927
1928   /* Read the abbrevs for this compilation unit into a table.  */
1929   abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
1930   if (! abbrevs)
1931       return 0;
1932
1933   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1934   info_ptr += bytes_read;
1935   if (! abbrev_number)
1936     {
1937       (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
1938                          abbrev_number);
1939       bfd_set_error (bfd_error_bad_value);
1940       return 0;
1941     }
1942
1943   abbrev = lookup_abbrev (abbrev_number, abbrevs);
1944   if (! abbrev)
1945     {
1946       (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1947                          abbrev_number);
1948       bfd_set_error (bfd_error_bad_value);
1949       return 0;
1950     }
1951
1952   amt = sizeof (struct comp_unit);
1953   unit = bfd_zalloc (abfd, amt);
1954   unit->abfd = abfd;
1955   unit->addr_size = addr_size;
1956   unit->offset_size = offset_size;
1957   unit->abbrevs = abbrevs;
1958   unit->end_ptr = end_ptr;
1959   unit->stash = stash;
1960   unit->info_ptr_unit = info_ptr_unit;
1961
1962   for (i = 0; i < abbrev->num_attrs; ++i)
1963     {
1964       info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1965
1966       /* Store the data if it is of an attribute we want to keep in a
1967          partial symbol table.  */
1968       switch (attr.name)
1969         {
1970         case DW_AT_stmt_list:
1971           unit->stmtlist = 1;
1972           unit->line_offset = attr.u.val;
1973           break;
1974
1975         case DW_AT_name:
1976           unit->name = attr.u.str;
1977           break;
1978
1979         case DW_AT_low_pc:
1980           low_pc = attr.u.val;
1981           /* If the compilation unit DIE has a DW_AT_low_pc attribute,
1982              this is the base address to use when reading location
1983              lists or range lists. */
1984           unit->base_address = low_pc;
1985           break;
1986
1987         case DW_AT_high_pc:
1988           high_pc = attr.u.val;
1989           break;
1990
1991         case DW_AT_ranges:
1992           read_rangelist (unit, &unit->arange, attr.u.val);
1993           break;
1994
1995         case DW_AT_comp_dir:
1996           {
1997             char *comp_dir = attr.u.str;
1998             if (comp_dir)
1999               {
2000                 /* Irix 6.2 native cc prepends <machine>.: to the compilation
2001                    directory, get rid of it.  */
2002                 char *cp = strchr (comp_dir, ':');
2003
2004                 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
2005                   comp_dir = cp + 1;
2006               }
2007             unit->comp_dir = comp_dir;
2008             break;
2009           }
2010
2011         default:
2012           break;
2013         }
2014     }
2015   if (high_pc != 0)
2016     {
2017       arange_add (unit->abfd, &unit->arange, low_pc, high_pc);
2018     }
2019
2020   unit->first_child_die_ptr = info_ptr;
2021   return unit;
2022 }
2023
2024 /* Return TRUE if UNIT may contain the address given by ADDR.  When
2025    there are functions written entirely with inline asm statements, the
2026    range info in the compilation unit header may not be correct.  We
2027    need to consult the line info table to see if a compilation unit
2028    really contains the given address.  */
2029
2030 static bfd_boolean
2031 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
2032 {
2033   struct arange *arange;
2034
2035   if (unit->error)
2036     return FALSE;
2037
2038   arange = &unit->arange;
2039   do
2040     {
2041       if (addr >= arange->low && addr < arange->high)
2042         return TRUE;
2043       arange = arange->next;
2044     }
2045   while (arange);
2046
2047   return FALSE;
2048 }
2049
2050 /* If UNIT contains ADDR, set the output parameters to the values for
2051    the line containing ADDR.  The output parameters, FILENAME_PTR,
2052    FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
2053    to be filled in.
2054
2055    Return TRUE if UNIT contains ADDR, and no errors were encountered;
2056    FALSE otherwise.  */
2057
2058 static bfd_boolean
2059 comp_unit_find_nearest_line (struct comp_unit *unit,
2060                              bfd_vma addr,
2061                              const char **filename_ptr,
2062                              const char **functionname_ptr,
2063                              unsigned int *linenumber_ptr,
2064                              struct dwarf2_debug *stash)
2065 {
2066   bfd_boolean line_p;
2067   bfd_boolean func_p;
2068   struct funcinfo *function;
2069
2070   if (unit->error)
2071     return FALSE;
2072
2073   if (! unit->line_table)
2074     {
2075       if (! unit->stmtlist)
2076         {
2077           unit->error = 1;
2078           return FALSE;
2079         }
2080
2081       unit->line_table = decode_line_info (unit, stash);
2082
2083       if (! unit->line_table)
2084         {
2085           unit->error = 1;
2086           return FALSE;
2087         }
2088
2089       if (unit->first_child_die_ptr < unit->end_ptr
2090           && ! scan_unit_for_symbols (unit))
2091         {
2092           unit->error = 1;
2093           return FALSE;
2094         }
2095     }
2096
2097   function = NULL;
2098   func_p = lookup_address_in_function_table (unit, addr,
2099                                              &function, functionname_ptr);
2100   if (func_p && (function->tag == DW_TAG_inlined_subroutine))
2101     stash->inliner_chain = function;
2102   line_p = lookup_address_in_line_info_table (unit->line_table, addr,
2103                                               function, filename_ptr,
2104                                               linenumber_ptr);
2105   return line_p || func_p;
2106 }
2107
2108 /* If UNIT contains SYM at ADDR, set the output parameters to the
2109    values for the line containing SYM.  The output parameters,
2110    FILENAME_PTR, and LINENUMBER_PTR, are pointers to the objects to be
2111    filled in.
2112
2113    Return TRUE if UNIT contains SYM, and no errors were encountered;
2114    FALSE otherwise.  */
2115
2116 static bfd_boolean
2117 comp_unit_find_line (struct comp_unit *unit,
2118                      asymbol *sym,
2119                      bfd_vma addr,
2120                      const char **filename_ptr,
2121                      unsigned int *linenumber_ptr,
2122                      struct dwarf2_debug *stash)
2123 {
2124   if (unit->error)
2125     return FALSE;
2126
2127   if (! unit->line_table)
2128     {
2129       if (! unit->stmtlist)
2130         {
2131           unit->error = 1;
2132           return FALSE;
2133         }
2134
2135       unit->line_table = decode_line_info (unit, stash);
2136
2137       if (! unit->line_table)
2138         {
2139           unit->error = 1;
2140           return FALSE;
2141         }
2142
2143       if (unit->first_child_die_ptr < unit->end_ptr
2144           && ! scan_unit_for_symbols (unit))
2145         {
2146           unit->error = 1;
2147           return FALSE;
2148         }
2149     }
2150
2151   if (sym->flags & BSF_FUNCTION)
2152     return lookup_symbol_in_function_table (unit, sym, addr,
2153                                             filename_ptr,
2154                                             linenumber_ptr);
2155   else
2156     return lookup_symbol_in_variable_table (unit, sym, addr,
2157                                             filename_ptr,
2158                                             linenumber_ptr);
2159 }
2160
2161 /* Locate a section in a BFD containing debugging info.  The search starts
2162    from the section after AFTER_SEC, or from the first section in the BFD if
2163    AFTER_SEC is NULL.  The search works by examining the names of the
2164    sections.  There are two permissiable names.  The first is .debug_info.
2165    This is the standard DWARF2 name.  The second is a prefix .gnu.linkonce.wi.
2166    This is a variation on the .debug_info section which has a checksum
2167    describing the contents appended onto the name.  This allows the linker to
2168    identify and discard duplicate debugging sections for different
2169    compilation units.  */
2170 #define DWARF2_DEBUG_INFO ".debug_info"
2171 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
2172
2173 static asection *
2174 find_debug_info (bfd *abfd, asection *after_sec)
2175 {
2176   asection * msec;
2177
2178   if (after_sec)
2179     msec = after_sec->next;
2180   else
2181     msec = abfd->sections;
2182
2183   while (msec)
2184     {
2185       if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
2186         return msec;
2187
2188       if (strncmp (msec->name, GNU_LINKONCE_INFO, strlen (GNU_LINKONCE_INFO)) == 0)
2189         return msec;
2190
2191       msec = msec->next;
2192     }
2193
2194   return NULL;
2195 }
2196
2197 /* Unset vmas for loadable sections in STASH.  */
2198
2199 static void
2200 unset_sections (struct dwarf2_debug *stash)
2201 {
2202   unsigned int i;
2203   struct loadable_section *p;
2204
2205   i = stash->loadable_section_count;
2206   p = stash->loadable_sections;
2207   for (; i > 0; i--, p++)
2208     p->section->vma = 0;
2209 }
2210
2211 /* Set unique vmas for loadable sections in ABFD and save vmas in
2212    STASH for unset_sections.  */
2213
2214 static bfd_boolean
2215 place_sections (bfd *abfd, struct dwarf2_debug *stash)
2216 {
2217   struct loadable_section *p;
2218   unsigned int i;
2219
2220   if (stash->loadable_section_count != 0)
2221     {
2222       i = stash->loadable_section_count;
2223       p = stash->loadable_sections;
2224       for (; i > 0; i--, p++)
2225         p->section->vma = p->adj_vma;
2226     }
2227   else
2228     {
2229       asection *sect;
2230       bfd_vma last_vma = 0;
2231       bfd_size_type amt;
2232       struct loadable_section *p;
2233
2234       i = 0;
2235       for (sect = abfd->sections; sect != NULL; sect = sect->next)
2236         {
2237           bfd_size_type sz;
2238
2239           if (sect->vma != 0 || (sect->flags & SEC_LOAD) == 0)
2240             continue;
2241
2242           sz = sect->rawsize ? sect->rawsize : sect->size;
2243           if (sz == 0)
2244             continue;
2245
2246           i++;
2247         }
2248
2249       amt = i * sizeof (struct loadable_section);
2250       p = (struct loadable_section *) bfd_zalloc (abfd, amt);
2251       if (! p)
2252         return FALSE;
2253
2254       stash->loadable_sections = p;
2255       stash->loadable_section_count = i;
2256
2257       for (sect = abfd->sections; sect != NULL; sect = sect->next)
2258         {
2259           bfd_size_type sz;
2260
2261           if (sect->vma != 0 || (sect->flags & SEC_LOAD) == 0)
2262             continue;
2263
2264           sz = sect->rawsize ? sect->rawsize : sect->size;
2265           if (sz == 0)
2266             continue;
2267
2268           p->section = sect;
2269           if (last_vma != 0)
2270             {
2271               /* Align the new address to the current section
2272                  alignment.  */
2273               last_vma = ((last_vma
2274                            + ~((bfd_vma) -1 << sect->alignment_power))
2275                           & ((bfd_vma) -1 << sect->alignment_power));
2276               sect->vma = last_vma;
2277             }
2278           p->adj_vma = sect->vma;
2279           last_vma += sect->vma + sz;
2280
2281           p++;
2282         }
2283     }
2284
2285   return TRUE;
2286 }
2287
2288 /* The DWARF2 version of find_nearest_line.  Return TRUE if the line
2289    is found without error.  ADDR_SIZE is the number of bytes in the
2290    initial .debug_info length field and in the abbreviation offset.
2291    You may use zero to indicate that the default value should be
2292    used.  */
2293
2294 bfd_boolean
2295 _bfd_dwarf2_find_nearest_line (bfd *abfd,
2296                                asection *section,
2297                                asymbol **symbols,
2298                                bfd_vma offset,
2299                                const char **filename_ptr,
2300                                const char **functionname_ptr,
2301                                unsigned int *linenumber_ptr,
2302                                unsigned int addr_size,
2303                                void **pinfo)
2304 {
2305   /* Read each compilation unit from the section .debug_info, and check
2306      to see if it contains the address we are searching for.  If yes,
2307      lookup the address, and return the line number info.  If no, go
2308      on to the next compilation unit.
2309
2310      We keep a list of all the previously read compilation units, and
2311      a pointer to the next un-read compilation unit.  Check the
2312      previously read units before reading more.  */
2313   struct dwarf2_debug *stash;
2314
2315   /* What address are we looking for?  */
2316   bfd_vma addr;
2317
2318   struct comp_unit* each;
2319
2320   bfd_vma found = FALSE;
2321
2322   stash = *pinfo;
2323
2324   if (! stash)
2325     {
2326       bfd_size_type amt = sizeof (struct dwarf2_debug);
2327
2328       stash = bfd_zalloc (abfd, amt);
2329       if (! stash)
2330         return FALSE;
2331     }
2332
2333   /* In a relocatable file, 2 functions may have the same address.
2334      We change the section vma so that they won't overlap.  */
2335   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2336     {
2337       if (! place_sections (abfd, stash))
2338         return FALSE;
2339     }
2340
2341   addr = offset;
2342   if (section->output_section)
2343     addr += section->output_section->vma + section->output_offset;
2344   else
2345     addr += section->vma;
2346   *filename_ptr = NULL;
2347   *functionname_ptr = NULL;
2348   *linenumber_ptr = 0;
2349
2350   /* The DWARF2 spec says that the initial length field, and the
2351      offset of the abbreviation table, should both be 4-byte values.
2352      However, some compilers do things differently.  */
2353   if (addr_size == 0)
2354     addr_size = 4;
2355   BFD_ASSERT (addr_size == 4 || addr_size == 8);
2356
2357   if (! *pinfo)
2358     {
2359       bfd_size_type total_size;
2360       asection *msec;
2361
2362       *pinfo = stash;
2363
2364       msec = find_debug_info (abfd, NULL);
2365       if (! msec)
2366         /* No dwarf2 info.  Note that at this point the stash
2367            has been allocated, but contains zeros, this lets
2368            future calls to this function fail quicker.  */
2369         goto done;
2370
2371       /* There can be more than one DWARF2 info section in a BFD these days.
2372          Read them all in and produce one large stash.  We do this in two
2373          passes - in the first pass we just accumulate the section sizes.
2374          In the second pass we read in the section's contents.  The allows
2375          us to avoid reallocing the data as we add sections to the stash.  */
2376       for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
2377         total_size += msec->size;
2378
2379       stash->info_ptr = bfd_alloc (abfd, total_size);
2380       if (stash->info_ptr == NULL)
2381         goto done;
2382
2383       stash->info_ptr_end = stash->info_ptr;
2384
2385       for (msec = find_debug_info (abfd, NULL);
2386            msec;
2387            msec = find_debug_info (abfd, msec))
2388         {
2389           bfd_size_type size;
2390           bfd_size_type start;
2391
2392           size = msec->size;
2393           if (size == 0)
2394             continue;
2395
2396           start = stash->info_ptr_end - stash->info_ptr;
2397
2398           if ((bfd_simple_get_relocated_section_contents
2399                (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
2400             continue;
2401
2402           stash->info_ptr_end = stash->info_ptr + start + size;
2403         }
2404
2405       BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
2406
2407       stash->sec = find_debug_info (abfd, NULL);
2408       stash->sec_info_ptr = stash->info_ptr;
2409       stash->syms = symbols;
2410     }
2411
2412   /* A null info_ptr indicates that there is no dwarf2 info
2413      (or that an error occured while setting up the stash).  */
2414   if (! stash->info_ptr)
2415     goto done;
2416
2417   stash->inliner_chain = NULL;
2418
2419   /* Check the previously read comp. units first.  */
2420   for (each = stash->all_comp_units; each; each = each->next_unit)
2421     if (comp_unit_contains_address (each, addr)
2422         && comp_unit_find_nearest_line (each, addr, filename_ptr,
2423                                         functionname_ptr,
2424                                         linenumber_ptr, stash))
2425       {
2426         found = TRUE;
2427         goto done;
2428       }
2429
2430   /* Read each remaining comp. units checking each as they are read.  */
2431   while (stash->info_ptr < stash->info_ptr_end)
2432     {
2433       bfd_vma length;
2434       unsigned int offset_size = addr_size;
2435       bfd_byte *info_ptr_unit = stash->info_ptr;
2436
2437       length = read_4_bytes (abfd, stash->info_ptr);
2438       /* A 0xffffff length is the DWARF3 way of indicating we use
2439          64-bit offsets, instead of 32-bit offsets.  */
2440       if (length == 0xffffffff)
2441         {
2442           offset_size = 8;
2443           length = read_8_bytes (abfd, stash->info_ptr + 4);
2444           stash->info_ptr += 12;
2445         }
2446       /* A zero length is the IRIX way of indicating 64-bit offsets,
2447          mostly because the 64-bit length will generally fit in 32
2448          bits, and the endianness helps.  */
2449       else if (length == 0)
2450         {
2451           offset_size = 8;
2452           length = read_4_bytes (abfd, stash->info_ptr + 4);
2453           stash->info_ptr += 8;
2454         }
2455       /* In the absence of the hints above, we assume addr_size-sized
2456          offsets, for backward-compatibility with pre-DWARF3 64-bit
2457          platforms.  */
2458       else if (addr_size == 8)
2459         {
2460           length = read_8_bytes (abfd, stash->info_ptr);
2461           stash->info_ptr += 8;
2462         }
2463       else
2464         stash->info_ptr += 4;
2465
2466       if (length > 0)
2467         {
2468           each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
2469                                   offset_size);
2470           stash->info_ptr += length;
2471
2472           if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
2473               == stash->sec->size)
2474             {
2475               stash->sec = find_debug_info (abfd, stash->sec);
2476               stash->sec_info_ptr = stash->info_ptr;
2477             }
2478
2479           if (each)
2480             {
2481               each->next_unit = stash->all_comp_units;
2482               stash->all_comp_units = each;
2483
2484               /* DW_AT_low_pc and DW_AT_high_pc are optional for
2485                  compilation units.  If we don't have them (i.e.,
2486                  unit->high == 0), we need to consult the line info
2487                  table to see if a compilation unit contains the given
2488                  address.  */
2489               if ((each->arange.high == 0
2490                    || comp_unit_contains_address (each, addr))
2491                   && comp_unit_find_nearest_line (each, addr,
2492                                                   filename_ptr,
2493                                                   functionname_ptr,
2494                                                   linenumber_ptr,
2495                                                   stash))
2496                 {
2497                   found = TRUE;
2498                   goto done;
2499                 }
2500             }
2501         }
2502     }
2503
2504 done:
2505   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2506     unset_sections (stash);
2507
2508   return found;
2509 }
2510
2511 /* The DWARF2 version of find_line.  Return TRUE if the line is found
2512    without error.  */
2513
2514 bfd_boolean
2515 _bfd_dwarf2_find_line (bfd *abfd,
2516                        asymbol **symbols,
2517                        asymbol *symbol,
2518                        const char **filename_ptr,
2519                        unsigned int *linenumber_ptr,
2520                        unsigned int addr_size,
2521                        void **pinfo)
2522 {
2523   /* Read each compilation unit from the section .debug_info, and check
2524      to see if it contains the address we are searching for.  If yes,
2525      lookup the address, and return the line number info.  If no, go
2526      on to the next compilation unit.
2527
2528      We keep a list of all the previously read compilation units, and
2529      a pointer to the next un-read compilation unit.  Check the
2530      previously read units before reading more.  */
2531   struct dwarf2_debug *stash;
2532
2533   /* What address are we looking for?  */
2534   bfd_vma addr;
2535
2536   struct comp_unit* each;
2537
2538   asection *section;
2539
2540   bfd_boolean found = FALSE;
2541
2542   section = bfd_get_section (symbol);
2543
2544   stash = *pinfo;
2545
2546   if (! stash)
2547     {
2548       bfd_size_type amt = sizeof (struct dwarf2_debug);
2549
2550       stash = bfd_zalloc (abfd, amt);
2551       if (! stash)
2552         return FALSE;
2553     }
2554
2555   /* In a relocatable file, 2 functions may have the same address.
2556      We change the section vma so that they won't overlap.  */
2557   if (!stash && (abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2558     {
2559       if (! place_sections (abfd, stash))
2560         return FALSE;
2561     }
2562
2563   addr = symbol->value;
2564   if (section->output_section)
2565     addr += section->output_section->vma + section->output_offset;
2566   else
2567     addr += section->vma;
2568
2569   *filename_ptr = NULL;
2570   *filename_ptr = NULL;
2571   *linenumber_ptr = 0;
2572
2573   if (! *pinfo)
2574     {
2575       bfd_size_type total_size;
2576       asection *msec;
2577
2578       *pinfo = stash;
2579
2580       msec = find_debug_info (abfd, NULL);
2581       if (! msec)
2582         /* No dwarf2 info.  Note that at this point the stash
2583            has been allocated, but contains zeros, this lets
2584            future calls to this function fail quicker.  */
2585         goto done;
2586
2587       /* There can be more than one DWARF2 info section in a BFD these days.
2588          Read them all in and produce one large stash.  We do this in two
2589          passes - in the first pass we just accumulate the section sizes.
2590          In the second pass we read in the section's contents.  The allows
2591          us to avoid reallocing the data as we add sections to the stash.  */
2592       for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
2593         total_size += msec->size;
2594
2595       stash->info_ptr = bfd_alloc (abfd, total_size);
2596       if (stash->info_ptr == NULL)
2597         goto done;
2598
2599       stash->info_ptr_end = stash->info_ptr;
2600
2601       for (msec = find_debug_info (abfd, NULL);
2602            msec;
2603            msec = find_debug_info (abfd, msec))
2604         {
2605           bfd_size_type size;
2606           bfd_size_type start;
2607
2608           size = msec->size;
2609           if (size == 0)
2610             continue;
2611
2612           start = stash->info_ptr_end - stash->info_ptr;
2613
2614           if ((bfd_simple_get_relocated_section_contents
2615                (abfd, msec, stash->info_ptr + start, symbols)) == NULL)
2616             continue;
2617
2618           stash->info_ptr_end = stash->info_ptr + start + size;
2619         }
2620
2621       BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
2622
2623       stash->sec = find_debug_info (abfd, NULL);
2624       stash->sec_info_ptr = stash->info_ptr;
2625       stash->syms = symbols;
2626     }
2627
2628   /* A null info_ptr indicates that there is no dwarf2 info
2629      (or that an error occured while setting up the stash).  */
2630   if (! stash->info_ptr)
2631     goto done;
2632
2633   stash->inliner_chain = NULL;
2634
2635   /* Check the previously read comp. units first.  */
2636   for (each = stash->all_comp_units; each; each = each->next_unit)
2637     if ((symbol->flags & BSF_FUNCTION) == 0
2638         || comp_unit_contains_address (each, addr))
2639       {
2640         found = comp_unit_find_line (each, symbol, addr, filename_ptr,
2641                                      linenumber_ptr, stash);
2642         if (found)
2643           goto done;
2644       }
2645
2646   /* The DWARF2 spec says that the initial length field, and the
2647      offset of the abbreviation table, should both be 4-byte values.
2648      However, some compilers do things differently.  */
2649   if (addr_size == 0)
2650     addr_size = 4;
2651   BFD_ASSERT (addr_size == 4 || addr_size == 8);
2652
2653   /* Read each remaining comp. units checking each as they are read.  */
2654   while (stash->info_ptr < stash->info_ptr_end)
2655     {
2656       bfd_vma length;
2657       unsigned int offset_size = addr_size;
2658       bfd_byte *info_ptr_unit = stash->info_ptr;
2659
2660       length = read_4_bytes (abfd, stash->info_ptr);
2661       /* A 0xffffff length is the DWARF3 way of indicating we use
2662          64-bit offsets, instead of 32-bit offsets.  */
2663       if (length == 0xffffffff)
2664         {
2665           offset_size = 8;
2666           length = read_8_bytes (abfd, stash->info_ptr + 4);
2667           stash->info_ptr += 12;
2668         }
2669       /* A zero length is the IRIX way of indicating 64-bit offsets,
2670          mostly because the 64-bit length will generally fit in 32
2671          bits, and the endianness helps.  */
2672       else if (length == 0)
2673         {
2674           offset_size = 8;
2675           length = read_4_bytes (abfd, stash->info_ptr + 4);
2676           stash->info_ptr += 8;
2677         }
2678       /* In the absence of the hints above, we assume addr_size-sized
2679          offsets, for backward-compatibility with pre-DWARF3 64-bit
2680          platforms.  */
2681       else if (addr_size == 8)
2682         {
2683           length = read_8_bytes (abfd, stash->info_ptr);
2684           stash->info_ptr += 8;
2685         }
2686       else
2687         stash->info_ptr += 4;
2688
2689       if (length > 0)
2690         {
2691           each = parse_comp_unit (abfd, stash, length, info_ptr_unit,
2692                                   offset_size);
2693           stash->info_ptr += length;
2694
2695           if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
2696               == stash->sec->size)
2697             {
2698               stash->sec = find_debug_info (abfd, stash->sec);
2699               stash->sec_info_ptr = stash->info_ptr;
2700             }
2701
2702           if (each)
2703             {
2704               each->next_unit = stash->all_comp_units;
2705               stash->all_comp_units = each;
2706
2707               /* DW_AT_low_pc and DW_AT_high_pc are optional for
2708                  compilation units.  If we don't have them (i.e.,
2709                  unit->high == 0), we need to consult the line info
2710                  table to see if a compilation unit contains the given
2711                  address.  */
2712               found = (((symbol->flags & BSF_FUNCTION) == 0
2713                         || each->arange.high <= 0
2714                         || comp_unit_contains_address (each, addr))
2715                        && comp_unit_find_line (each, symbol, addr,
2716                                                filename_ptr,
2717                                                linenumber_ptr,
2718                                                stash));
2719               if (found)
2720                 goto done;
2721             }
2722         }
2723     }
2724
2725 done:
2726   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2727     unset_sections (stash);
2728
2729   return found;
2730 }
2731
2732 bfd_boolean
2733 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
2734                                const char **filename_ptr,
2735                                const char **functionname_ptr,
2736                                unsigned int *linenumber_ptr,
2737                                void **pinfo)
2738 {
2739   struct dwarf2_debug *stash;
2740
2741   stash = *pinfo;
2742   if (stash)
2743     {
2744       struct funcinfo *func = stash->inliner_chain;
2745       if (func && func->caller_func)
2746         {
2747           *filename_ptr = func->caller_file;
2748           *functionname_ptr = func->caller_func->name;
2749           *linenumber_ptr = func->caller_line;
2750           stash->inliner_chain = func->caller_func;
2751           return (TRUE);
2752         }
2753     }
2754
2755   return (FALSE);
2756 }
2757
2758 void
2759 _bfd_dwarf2_cleanup_debug_info (bfd *abfd)
2760 {
2761   struct comp_unit *each;
2762   struct dwarf2_debug *stash;
2763
2764   if (abfd == NULL || elf_tdata (abfd) == NULL)
2765     return;
2766
2767   stash = elf_tdata (abfd)->dwarf2_find_line_info;
2768
2769   if (stash == NULL)
2770     return;
2771
2772   for (each = stash->all_comp_units; each; each = each->next_unit)
2773     {
2774       struct abbrev_info **abbrevs = each->abbrevs;
2775       size_t i;
2776
2777       for (i = 0; i < ABBREV_HASH_SIZE; i++)
2778         {
2779           struct abbrev_info *abbrev = abbrevs[i];
2780
2781           while (abbrev)
2782             {
2783               free (abbrev->attrs);
2784               abbrev = abbrev->next;
2785             }
2786         }
2787
2788       if (each->line_table)
2789         {
2790           free (each->line_table->dirs);
2791           free (each->line_table->files);
2792         }
2793     }
2794
2795   free (stash->dwarf_abbrev_buffer);
2796   free (stash->dwarf_line_buffer);
2797   free (stash->dwarf_ranges_buffer);
2798 }