bfd/dwarf2.c

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