bfd/dwarf2.c

   1 /* DWARF 2 support.
   2    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
   3    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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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     unsigned int unsnd;
  65     int snd;
  66     bfd_vma addr;
  67   }
  68   u;
  69 };
  70
  71 /* Get at parts of an attribute structure.  */
  72
  73 #define DW_STRING(attr)    ((attr)->u.str)
  74 #define DW_UNSND(attr)     ((attr)->u.unsnd)
  75 #define DW_BLOCK(attr)     ((attr)->u.blk)
  76 #define DW_SND(attr)       ((attr)->u.snd)
  77 #define DW_ADDR(attr)      ((attr)->u.addr)
  78
  79 /* Blocks are a bunch of untyped bytes.  */
  80 struct dwarf_block
  81 {
  82   unsigned int size;
  83   char *data;
  84 };
  85
  86 struct dwarf2_debug
  87 {
  88   /* A list of all previously read comp_units.  */
  89   struct comp_unit* all_comp_units;
  90
  91   /* The next unread compilation unit within the .debug_info section.
  92      Zero indicates that the .debug_info section has not been loaded
  93      into a buffer yet.  */
  94   char* info_ptr;
  95
  96   /* Pointer to the end of the .debug_info section memory buffer.  */
  97   char* info_ptr_end;
  98
  99   /* Pointer to the section and address of the beginning of the
 100      section.  */
 101   asection* sec;
 102   char* sec_info_ptr;
 103
 104   /* Pointer to the symbol table.  */
 105   asymbol** syms;
 106
 107   /* Pointer to the .debug_abbrev section loaded into memory.  */
 108   char* dwarf_abbrev_buffer;
 109
 110   /* Length of the loaded .debug_abbrev section.  */
 111   unsigned long dwarf_abbrev_size;
 112
 113   /* Buffer for decode_line_info.  */
 114   char *dwarf_line_buffer;
 115
 116   /* Length of the loaded .debug_line section.  */
 117   unsigned long dwarf_line_size;
 118
 119   /* Pointer to the .debug_str section loaded into memory.  */
 120   char* dwarf_str_buffer;
 121
 122   /* Length of the loaded .debug_str section.  */
 123   unsigned long dwarf_str_size;
 124 };
 125
 126 struct arange
 127 {
 128   struct arange *next;
 129   bfd_vma low;
 130   bfd_vma high;
 131 };
 132
 133 /* A minimal decoding of DWARF2 compilation units.  We only decode
 134    what's needed to get to the line number information.  */
 135
 136 struct comp_unit
 137 {
 138   /* Chain the previously read compilation units.  */
 139   struct comp_unit* next_unit;
 140
 141   /* Keep the bdf convenient (for memory allocation).  */
 142   bfd* abfd;
 143
 144   /* The lowest and higest addresses contained in this compilation
 145      unit as specified in the compilation unit header.  */
 146   struct arange arange;
 147
 148   /* The DW_AT_name attribute (for error messages).  */
 149   char* name;
 150
 151   /* The abbrev hash table.  */
 152   struct abbrev_info** abbrevs;
 153
 154   /* Note that an error was found by comp_unit_find_nearest_line.  */
 155   int error;
 156
 157   /* The DW_AT_comp_dir attribute.  */
 158   char* comp_dir;
 159
 160   /* True if there is a line number table associated with this comp. unit.  */
 161   int stmtlist;
 162
 163   /* The offset into .debug_line of the line number table.  */
 164   unsigned long line_offset;
 165
 166   /* Pointer to the first child die for the comp unit.  */
 167   char *first_child_die_ptr;
 168
 169   /* The end of the comp unit.  */
 170   char *end_ptr;
 171
 172   /* The decoded line number, NULL if not yet decoded.  */
 173   struct line_info_table* line_table;
 174
 175   /* A list of the functions found in this comp. unit.  */
 176   struct funcinfo* function_table;
 177
 178   /* Pointer to dwarf2_debug structure.  */
 179   struct dwarf2_debug *stash;
 180
 181   /* Address size for this unit - from unit header.  */
 182   unsigned char addr_size;
 183
 184   /* Offset size for this unit - from unit header.  */
 185   unsigned char offset_size;
 186 };
 187
 188 /* This data structure holds the information of an abbrev.  */
 189 struct abbrev_info
 190 {
 191   unsigned int number;          /* Number identifying abbrev.  */
 192   enum dwarf_tag tag;           /* DWARF tag.  */
 193   int has_children;             /* Boolean.  */
 194   unsigned int num_attrs;       /* Number of attributes.  */
 195   struct attr_abbrev *attrs;    /* An array of attribute descriptions.  */
 196   struct abbrev_info *next;     /* Next in chain.  */
 197 };
 198
 199 struct attr_abbrev
 200 {
 201   enum dwarf_attribute name;
 202   enum dwarf_form form;
 203 };
 204
 205 #ifndef ABBREV_HASH_SIZE
 206 #define ABBREV_HASH_SIZE 121
 207 #endif
 208 #ifndef ATTR_ALLOC_CHUNK
 209 #define ATTR_ALLOC_CHUNK 4
 210 #endif
 211
 212 static unsigned int read_1_byte PARAMS ((bfd *, char *));
 213 static int read_1_signed_byte PARAMS ((bfd *, char *));
 214 static unsigned int read_2_bytes PARAMS ((bfd *, char *));
 215 static unsigned int read_4_bytes PARAMS ((bfd *, char *));
 216 static bfd_vma read_8_bytes PARAMS ((bfd *, char *));
 217 static char *read_n_bytes PARAMS ((bfd *, char *, unsigned int));
 218 static char *read_string PARAMS ((bfd *, char *, unsigned int *));
 219 static char *read_indirect_string PARAMS ((struct comp_unit *, char *, unsigned int *));
 220 static unsigned int read_unsigned_leb128
 221   PARAMS ((bfd *, char *, unsigned int *));
 222 static int read_signed_leb128
 223   PARAMS ((bfd *, char *, unsigned int *));
 224 static bfd_vma read_address PARAMS ((struct comp_unit *, char *));
 225 static struct abbrev_info *lookup_abbrev
 226   PARAMS ((unsigned int, struct abbrev_info **));
 227 static struct abbrev_info **read_abbrevs
 228   PARAMS ((bfd *, bfd_vma, struct dwarf2_debug *));
 229 static char *read_attribute
 230   PARAMS ((struct attribute *, struct attr_abbrev *,
 231            struct comp_unit *, char *));
 232 static char *read_attribute_value
 233   PARAMS ((struct attribute *, unsigned,
 234            struct comp_unit *, char *));
 235 static void add_line_info
 236   PARAMS ((struct line_info_table *, bfd_vma, char *,
 237            unsigned int, unsigned int, int));
 238 static char *concat_filename PARAMS ((struct line_info_table *, unsigned int));
 239 static void arange_add PARAMS ((struct comp_unit *, bfd_vma, bfd_vma));
 240 static struct line_info_table *decode_line_info
 241   PARAMS ((struct comp_unit *, struct dwarf2_debug *));
 242 static boolean lookup_address_in_line_info_table
 243   PARAMS ((struct line_info_table *, bfd_vma, struct funcinfo *,
 244            const char **, unsigned int *));
 245 static boolean lookup_address_in_function_table
 246   PARAMS ((struct funcinfo *, bfd_vma, struct funcinfo **, const char **));
 247 static boolean scan_unit_for_functions PARAMS ((struct comp_unit *));
 248 static bfd_vma find_rela_addend
 249   PARAMS ((bfd *, asection *, bfd_size_type, asymbol**));
 250 static struct comp_unit *parse_comp_unit
 251   PARAMS ((bfd *, struct dwarf2_debug *, bfd_vma, unsigned int));
 252 static boolean comp_unit_contains_address
 253   PARAMS ((struct comp_unit *, bfd_vma));
 254 static boolean comp_unit_find_nearest_line
 255   PARAMS ((struct comp_unit *, bfd_vma, const char **, const char **,
 256            unsigned int *, struct dwarf2_debug *));
 257 static asection *find_debug_info PARAMS ((bfd *, asection *));
 258
 259 /* VERBATIM
 260    The following function up to the END VERBATIM mark are
 261    copied directly from dwarf2read.c.  */
 262
 263 /* Read dwarf information from a buffer.  */
 264
 265 static unsigned int
 266 read_1_byte (abfd, buf)
 267      bfd *abfd ATTRIBUTE_UNUSED;
 268      char *buf;
 269 {
 270   return bfd_get_8 (abfd, (bfd_byte *) buf);
 271 }
 272
 273 static int
 274 read_1_signed_byte (abfd, buf)
 275      bfd *abfd ATTRIBUTE_UNUSED;
 276      char *buf;
 277 {
 278   return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
 279 }
 280
 281 static unsigned int
 282 read_2_bytes (abfd, buf)
 283      bfd *abfd;
 284      char *buf;
 285 {
 286   return bfd_get_16 (abfd, (bfd_byte *) buf);
 287 }
 288
 289 #if 0  /* This is not used.  */
 290
 291 static int
 292 read_2_signed_bytes (abfd, buf)
 293      bfd *abfd;
 294      char *buf;
 295 {
 296   return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
 297 }
 298
 299 #endif
 300
 301 static unsigned int
 302 read_4_bytes (abfd, buf)
 303      bfd *abfd;
 304      char *buf;
 305 {
 306   return bfd_get_32 (abfd, (bfd_byte *) buf);
 307 }
 308
 309 #if 0  /* This is not used.  */
 310
 311 static int
 312 read_4_signed_bytes (abfd, buf)
 313      bfd *abfd;
 314      char *buf;
 315 {
 316   return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
 317 }
 318
 319 #endif
 320
 321 static bfd_vma
 322 read_8_bytes (abfd, buf)
 323      bfd *abfd;
 324      char *buf;
 325 {
 326   return bfd_get_64 (abfd, (bfd_byte *) buf);
 327 }
 328
 329 static char *
 330 read_n_bytes (abfd, buf, size)
 331      bfd *abfd ATTRIBUTE_UNUSED;
 332      char *buf;
 333      unsigned int size ATTRIBUTE_UNUSED;
 334 {
 335   /* If the size of a host char is 8 bits, we can return a pointer
 336      to the buffer, otherwise we have to copy the data to a buffer
 337      allocated on the temporary obstack.  */
 338   return buf;
 339 }
 340
 341 static char *
 342 read_string (abfd, buf, bytes_read_ptr)
 343      bfd *abfd ATTRIBUTE_UNUSED;
 344      char *buf;
 345      unsigned int *bytes_read_ptr;
 346 {
 347   /* Return a pointer to the embedded string.  */
 348   if (*buf == '\0')
 349     {
 350       *bytes_read_ptr = 1;
 351       return NULL;
 352     }
 353
 354   *bytes_read_ptr = strlen (buf) + 1;
 355   return buf;
 356 }
 357
 358 static char *
 359 read_indirect_string (unit, buf, bytes_read_ptr)
 360      struct comp_unit* unit;
 361      char *buf;
 362      unsigned int *bytes_read_ptr;
 363 {
 364   bfd_vma offset;
 365   struct dwarf2_debug *stash = unit->stash;
 366
 367   if (unit->offset_size == 4)
 368     offset = read_4_bytes (unit->abfd, buf);
 369   else
 370     offset = read_8_bytes (unit->abfd, buf);
 371   *bytes_read_ptr = unit->offset_size;
 372
 373   if (! stash->dwarf_str_buffer)
 374     {
 375       asection *msec;
 376       bfd *abfd = unit->abfd;
 377
 378       msec = bfd_get_section_by_name (abfd, ".debug_str");
 379       if (! msec)
 380         {
 381           (*_bfd_error_handler)
 382             (_("Dwarf Error: Can't find .debug_str section."));
 383           bfd_set_error (bfd_error_bad_value);
 384           return NULL;
 385         }
 386
 387       stash->dwarf_str_size = msec->_raw_size;
 388       stash->dwarf_str_buffer = (char*) bfd_alloc (abfd, msec->_raw_size);
 389       if (! stash->dwarf_abbrev_buffer)
 390         return NULL;
 391
 392       if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
 393                                       (bfd_vma) 0, msec->_raw_size))
 394         return NULL;
 395     }
 396
 397   if (offset >= stash->dwarf_str_size)
 398     {
 399       (*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%lu) greater than or equal to .debug_str size (%lu)."),
 400                              (unsigned long) offset, stash->dwarf_str_size);
 401       bfd_set_error (bfd_error_bad_value);
 402       return NULL;
 403     }
 404
 405   buf = stash->dwarf_str_buffer + offset;
 406   if (*buf == '\0')
 407     return NULL;
 408   return buf;
 409 }
 410
 411 static unsigned int
 412 read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
 413      bfd *abfd ATTRIBUTE_UNUSED;
 414      char *buf;
 415      unsigned int *bytes_read_ptr;
 416 {
 417   unsigned int  result;
 418   unsigned int  num_read;
 419   int           shift;
 420   unsigned char byte;
 421
 422   result   = 0;
 423   shift    = 0;
 424   num_read = 0;
 425
 426   do
 427     {
 428       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
 429       buf ++;
 430       num_read ++;
 431       result |= ((byte & 0x7f) << shift);
 432       shift += 7;
 433     }
 434   while (byte & 0x80);
 435
 436   * bytes_read_ptr = num_read;
 437
 438   return result;
 439 }
 440
 441 static int
 442 read_signed_leb128 (abfd, buf, bytes_read_ptr)
 443      bfd *abfd ATTRIBUTE_UNUSED;
 444      char *buf;
 445      unsigned int * bytes_read_ptr;
 446 {
 447   int           result;
 448   int           shift;
 449   int           num_read;
 450   unsigned char byte;
 451
 452   result = 0;
 453   shift = 0;
 454   num_read = 0;
 455
 456   do
 457     {
 458       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
 459       buf ++;
 460       num_read ++;
 461       result |= ((byte & 0x7f) << shift);
 462       shift += 7;
 463     }
 464   while (byte & 0x80);
 465
 466   if ((shift < 32) && (byte & 0x40))
 467     result |= -(1 << shift);
 468
 469   * bytes_read_ptr = num_read;
 470
 471   return result;
 472 }
 473
 474 /* END VERBATIM */
 475
 476 static bfd_vma
 477 read_address (unit, buf)
 478      struct comp_unit* unit;
 479      char *buf;
 480 {
 481   switch (unit->addr_size)
 482     {
 483     case 8:
 484       return bfd_get_64 (unit->abfd, (bfd_byte *) buf);
 485     case 4:
 486       return bfd_get_32 (unit->abfd, (bfd_byte *) buf);
 487     case 2:
 488       return bfd_get_16 (unit->abfd, (bfd_byte *) buf);
 489     default:
 490       abort ();
 491     }
 492 }
 493
 494 /* Lookup an abbrev_info structure in the abbrev hash table.  */
 495
 496 static struct abbrev_info *
 497 lookup_abbrev (number,abbrevs)
 498      unsigned int number;
 499      struct abbrev_info **abbrevs;
 500 {
 501   unsigned int hash_number;
 502   struct abbrev_info *abbrev;
 503
 504   hash_number = number % ABBREV_HASH_SIZE;
 505   abbrev = abbrevs[hash_number];
 506
 507   while (abbrev)
 508     {
 509       if (abbrev->number == number)
 510         return abbrev;
 511       else
 512         abbrev = abbrev->next;
 513     }
 514
 515   return NULL;
 516 }
 517
 518 /* In DWARF version 2, the description of the debugging information is
 519    stored in a separate .debug_abbrev section.  Before we read any
 520    dies from a section we read in all abbreviations and install them
 521    in a hash table.  */
 522
 523 static struct abbrev_info**
 524 read_abbrevs (abfd, offset, stash)
 525      bfd * abfd;
 526      bfd_vma offset;
 527      struct dwarf2_debug *stash;
 528 {
 529   struct abbrev_info **abbrevs;
 530   char *abbrev_ptr;
 531   struct abbrev_info *cur_abbrev;
 532   unsigned int abbrev_number, bytes_read, abbrev_name;
 533   unsigned int abbrev_form, hash_number;
 534   bfd_size_type amt;
 535
 536   if (! stash->dwarf_abbrev_buffer)
 537     {
 538       asection *msec;
 539
 540       msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
 541       if (! msec)
 542         {
 543           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
 544           bfd_set_error (bfd_error_bad_value);
 545           return 0;
 546         }
 547
 548       stash->dwarf_abbrev_size = msec->_raw_size;
 549       stash->dwarf_abbrev_buffer = (char*) bfd_alloc (abfd, msec->_raw_size);
 550       if (! stash->dwarf_abbrev_buffer)
 551           return 0;
 552
 553       if (! bfd_get_section_contents (abfd, msec, stash->dwarf_abbrev_buffer,
 554                                       (bfd_vma) 0, msec->_raw_size))
 555         return 0;
 556     }
 557
 558   if (offset >= stash->dwarf_abbrev_size)
 559     {
 560       (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%lu) greater than or equal to .debug_abbrev size (%lu)."),
 561                              (unsigned long) offset, stash->dwarf_abbrev_size);
 562       bfd_set_error (bfd_error_bad_value);
 563       return 0;
 564     }
 565
 566   amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
 567   abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, amt);
 568
 569   abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
 570   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 571   abbrev_ptr += bytes_read;
 572
 573   /* Loop until we reach an abbrev number of 0.  */
 574   while (abbrev_number)
 575     {
 576       amt = sizeof (struct abbrev_info);
 577       cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
 578
 579       /* Read in abbrev header.  */
 580       cur_abbrev->number = abbrev_number;
 581       cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 582       abbrev_ptr += bytes_read;
 583       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
 584       abbrev_ptr += 1;
 585
 586       /* Now read in declarations.  */
 587       abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 588       abbrev_ptr += bytes_read;
 589       abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 590       abbrev_ptr += bytes_read;
 591
 592       while (abbrev_name)
 593         {
 594           if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
 595             {
 596               amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
 597               amt *= sizeof (struct attr_abbrev);
 598               cur_abbrev->attrs = ((struct attr_abbrev *)
 599                                    bfd_realloc (cur_abbrev->attrs, amt));
 600               if (! cur_abbrev->attrs)
 601                 return 0;
 602             }
 603
 604           cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
 605           cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
 606           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 607           abbrev_ptr += bytes_read;
 608           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 609           abbrev_ptr += bytes_read;
 610         }
 611
 612       hash_number = abbrev_number % ABBREV_HASH_SIZE;
 613       cur_abbrev->next = abbrevs[hash_number];
 614       abbrevs[hash_number] = cur_abbrev;
 615
 616       /* Get next abbreviation.
 617          Under Irix6 the abbreviations for a compilation unit are not
 618          always properly terminated with an abbrev number of 0.
 619          Exit loop if we encounter an abbreviation which we have
 620          already read (which means we are about to read the abbreviations
 621          for the next compile unit) or if the end of the abbreviation
 622          table is reached.  */
 623       if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
 624             >= stash->dwarf_abbrev_size)
 625         break;
 626       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 627       abbrev_ptr += bytes_read;
 628       if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
 629         break;
 630     }
 631
 632   return abbrevs;
 633 }
 634
 635 /* Read an attribute value described by an attribute form.  */
 636
 637 static char *
 638 read_attribute_value (attr, form, unit, info_ptr)
 639      struct attribute   *attr;
 640      unsigned form;
 641      struct comp_unit   *unit;
 642      char               *info_ptr;
 643 {
 644   bfd *abfd = unit->abfd;
 645   unsigned int bytes_read;
 646   struct dwarf_block *blk;
 647   bfd_size_type amt;
 648
 649   attr->form = form;
 650
 651   switch (form)
 652     {
 653     case DW_FORM_addr:
 654       /* FIXME: DWARF3 draft sais DW_FORM_ref_addr is offset_size.  */
 655     case DW_FORM_ref_addr:
 656       DW_ADDR (attr) = read_address (unit, info_ptr);
 657       info_ptr += unit->addr_size;
 658       break;
 659     case DW_FORM_block2:
 660       amt = sizeof (struct dwarf_block);
 661       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
 662       blk->size = read_2_bytes (abfd, info_ptr);
 663       info_ptr += 2;
 664       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 665       info_ptr += blk->size;
 666       DW_BLOCK (attr) = blk;
 667       break;
 668     case DW_FORM_block4:
 669       amt = sizeof (struct dwarf_block);
 670       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
 671       blk->size = read_4_bytes (abfd, info_ptr);
 672       info_ptr += 4;
 673       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 674       info_ptr += blk->size;
 675       DW_BLOCK (attr) = blk;
 676       break;
 677     case DW_FORM_data2:
 678       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
 679       info_ptr += 2;
 680       break;
 681     case DW_FORM_data4:
 682       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
 683       info_ptr += 4;
 684       break;
 685     case DW_FORM_data8:
 686       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
 687       info_ptr += 8;
 688       break;
 689     case DW_FORM_string:
 690       DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
 691       info_ptr += bytes_read;
 692       break;
 693     case DW_FORM_strp:
 694       DW_STRING (attr) = read_indirect_string (unit, info_ptr, &bytes_read);
 695       info_ptr += bytes_read;
 696       break;
 697     case DW_FORM_block:
 698       amt = sizeof (struct dwarf_block);
 699       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
 700       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 701       info_ptr += bytes_read;
 702       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 703       info_ptr += blk->size;
 704       DW_BLOCK (attr) = blk;
 705       break;
 706     case DW_FORM_block1:
 707       amt = sizeof (struct dwarf_block);
 708       blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
 709       blk->size = read_1_byte (abfd, info_ptr);
 710       info_ptr += 1;
 711       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 712       info_ptr += blk->size;
 713       DW_BLOCK (attr) = blk;
 714       break;
 715     case DW_FORM_data1:
 716       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
 717       info_ptr += 1;
 718       break;
 719     case DW_FORM_flag:
 720       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
 721       info_ptr += 1;
 722       break;
 723     case DW_FORM_sdata:
 724       DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
 725       info_ptr += bytes_read;
 726       break;
 727     case DW_FORM_udata:
 728       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 729       info_ptr += bytes_read;
 730       break;
 731     case DW_FORM_ref1:
 732       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
 733       info_ptr += 1;
 734       break;
 735     case DW_FORM_ref2:
 736       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
 737       info_ptr += 2;
 738       break;
 739     case DW_FORM_ref4:
 740       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
 741       info_ptr += 4;
 742       break;
 743     case DW_FORM_ref8:
 744       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
 745       info_ptr += 8;
 746       break;
 747     case DW_FORM_ref_udata:
 748       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 749       info_ptr += bytes_read;
 750       break;
 751     case DW_FORM_indirect:
 752       form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 753       info_ptr += bytes_read;
 754       info_ptr = read_attribute_value (attr, form, unit, info_ptr);
 755       break;
 756     default:
 757       (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %u."),
 758                              form);
 759       bfd_set_error (bfd_error_bad_value);
 760     }
 761   return info_ptr;
 762 }
 763
 764 /* Read an attribute described by an abbreviated attribute.  */
 765
 766 static char *
 767 read_attribute (attr, abbrev, unit, info_ptr)
 768      struct attribute   *attr;
 769      struct attr_abbrev *abbrev;
 770      struct comp_unit   *unit;
 771      char               *info_ptr;
 772 {
 773   attr->name = abbrev->name;
 774   info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
 775   return info_ptr;
 776 }
 777
 778 /* Source line information table routines.  */
 779
 780 #define FILE_ALLOC_CHUNK 5
 781 #define DIR_ALLOC_CHUNK 5
 782
 783 struct line_info
 784 {
 785   struct line_info* prev_line;
 786   bfd_vma address;
 787   char* filename;
 788   unsigned int line;
 789   unsigned int column;
 790   int end_sequence;             /* End of (sequential) code sequence.  */
 791 };
 792
 793 struct fileinfo
 794 {
 795   char *name;
 796   unsigned int dir;
 797   unsigned int time;
 798   unsigned int size;
 799 };
 800
 801 struct line_info_table
 802 {
 803   bfd* abfd;
 804   unsigned int num_files;
 805   unsigned int num_dirs;
 806   char* comp_dir;
 807   char** dirs;
 808   struct fileinfo* files;
 809   struct line_info* last_line;
 810 };
 811
 812 struct funcinfo
 813 {
 814   struct funcinfo *prev_func;
 815   char* name;
 816   bfd_vma low;
 817   bfd_vma high;
 818 };
 819
 820 static void
 821 add_line_info (table, address, filename, line, column, end_sequence)
 822      struct line_info_table* table;
 823      bfd_vma address;
 824      char* filename;
 825      unsigned int line;
 826      unsigned int column;
 827      int end_sequence;
 828 {
 829   bfd_size_type amt = sizeof (struct line_info);
 830   struct line_info* info = (struct line_info*) bfd_alloc (table->abfd, amt);
 831
 832   info->prev_line = table->last_line;
 833   table->last_line = info;
 834
 835   info->address = address;
 836   info->filename = filename;
 837   info->line = line;
 838   info->column = column;
 839   info->end_sequence = end_sequence;
 840 }
 841
 842 static char *
 843 concat_filename (table, file)
 844      struct line_info_table* table;
 845      unsigned int file;
 846 {
 847   char* filename;
 848
 849   if (file - 1 >= table->num_files)
 850     {
 851       (*_bfd_error_handler)
 852         (_("Dwarf Error: mangled line number section (bad file number)."));
 853       return "<unknown>";
 854     }
 855
 856   filename = table->files[file - 1].name;
 857   if (IS_ABSOLUTE_PATH(filename))
 858     return filename;
 859   else
 860     {
 861       char* dirname = (table->files[file - 1].dir
 862                        ? table->dirs[table->files[file - 1].dir - 1]
 863                        : table->comp_dir);
 864
 865       /* Not all tools set DW_AT_comp_dir, so dirname may be unknown.  The
 866          best we can do is return the filename part.  */
 867       if (dirname == NULL)
 868         return filename;
 869       else
 870         return (char*) concat (dirname, "/", filename, NULL);
 871     }
 872 }
 873
 874 static void
 875 arange_add (unit, low_pc, high_pc)
 876      struct comp_unit *unit;
 877      bfd_vma low_pc;
 878      bfd_vma high_pc;
 879 {
 880   struct arange *arange;
 881
 882   /* First see if we can cheaply extend an existing range.  */
 883   arange = &unit->arange;
 884
 885   do
 886     {
 887       if (low_pc == arange->high)
 888         {
 889           arange->high = high_pc;
 890           return;
 891         }
 892       if (high_pc == arange->low)
 893         {
 894           arange->low = low_pc;
 895           return;
 896         }
 897       arange = arange->next;
 898     }
 899   while (arange);
 900
 901   if (unit->arange.high == 0)
 902     {
 903       /* This is the first address range: store it in unit->arange.  */
 904       unit->arange.next = 0;
 905       unit->arange.low = low_pc;
 906       unit->arange.high = high_pc;
 907       return;
 908     }
 909
 910   /* Need to allocate a new arange and insert it into the arange list.  */
 911   arange = bfd_zalloc (unit->abfd, (bfd_size_type) sizeof (*arange));
 912   arange->low = low_pc;
 913   arange->high = high_pc;
 914
 915   arange->next = unit->arange.next;
 916   unit->arange.next = arange;
 917 }
 918
 919 /* Decode the line number information for UNIT.  */
 920
 921 static struct line_info_table*
 922 decode_line_info (unit, stash)
 923      struct comp_unit *unit;
 924      struct dwarf2_debug *stash;
 925 {
 926   bfd *abfd = unit->abfd;
 927   struct line_info_table* table;
 928   char *line_ptr;
 929   char *line_end;
 930   struct line_head lh;
 931   unsigned int i, bytes_read, offset_size;
 932   char *cur_file, *cur_dir;
 933   unsigned char op_code, extended_op, adj_opcode;
 934   bfd_size_type amt;
 935
 936   if (! stash->dwarf_line_buffer)
 937     {
 938       asection *msec;
 939
 940       msec = bfd_get_section_by_name (abfd, ".debug_line");
 941       if (! msec)
 942         {
 943           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
 944           bfd_set_error (bfd_error_bad_value);
 945           return 0;
 946         }
 947
 948       stash->dwarf_line_size = msec->_raw_size;
 949       stash->dwarf_line_buffer = (char *) bfd_alloc (abfd, msec->_raw_size);
 950       if (! stash->dwarf_line_buffer)
 951         return 0;
 952
 953       if (! bfd_get_section_contents (abfd, msec, stash->dwarf_line_buffer,
 954                                       (bfd_vma) 0, msec->_raw_size))
 955         return 0;
 956
 957       /* FIXME: We ought to apply the relocs against this section before
 958          we process it...  */
 959     }
 960
 961   /* Since we are using un-relocated data, it is possible to get a bad value
 962      for the line_offset.  Validate it here so that we won't get a segfault
 963      below.  */
 964   if (unit->line_offset >= stash->dwarf_line_size)
 965     {
 966       (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
 967                              unit->line_offset, stash->dwarf_line_size);
 968       bfd_set_error (bfd_error_bad_value);
 969       return 0;
 970     }
 971
 972   amt = sizeof (struct line_info_table);
 973   table = (struct line_info_table*) bfd_alloc (abfd, amt);
 974   table->abfd = abfd;
 975   table->comp_dir = unit->comp_dir;
 976
 977   table->num_files = 0;
 978   table->files = NULL;
 979
 980   table->num_dirs = 0;
 981   table->dirs = NULL;
 982
 983   table->files = NULL;
 984   table->last_line = NULL;
 985
 986   line_ptr = stash->dwarf_line_buffer + unit->line_offset;
 987
 988   /* Read in the prologue.  */
 989   lh.total_length = read_4_bytes (abfd, line_ptr);
 990   line_ptr += 4;
 991   offset_size = 4;
 992   if (lh.total_length == 0xffffffff)
 993     {
 994       lh.total_length = read_8_bytes (abfd, line_ptr);
 995       line_ptr += 8;
 996       offset_size = 8;
 997     }
 998   else if (lh.total_length == 0 && unit->addr_size == 8)
 999     {
1000       /* Handle (non-standard) 64-bit DWARF2 formats.  */
1001       lh.total_length = read_4_bytes (abfd, line_ptr);
1002       line_ptr += 4;
1003       offset_size = 8;
1004     }
1005   line_end = line_ptr + lh.total_length;
1006   lh.version = read_2_bytes (abfd, line_ptr);
1007   line_ptr += 2;
1008   if (offset_size == 4)
1009     lh.prologue_length = read_4_bytes (abfd, line_ptr);
1010   else
1011     lh.prologue_length = read_8_bytes (abfd, line_ptr);
1012   line_ptr += offset_size;
1013   lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1014   line_ptr += 1;
1015   lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1016   line_ptr += 1;
1017   lh.line_base = read_1_signed_byte (abfd, line_ptr);
1018   line_ptr += 1;
1019   lh.line_range = read_1_byte (abfd, line_ptr);
1020   line_ptr += 1;
1021   lh.opcode_base = read_1_byte (abfd, line_ptr);
1022   line_ptr += 1;
1023   amt = lh.opcode_base * sizeof (unsigned char);
1024   lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1025
1026   lh.standard_opcode_lengths[0] = 1;
1027
1028   for (i = 1; i < lh.opcode_base; ++i)
1029     {
1030       lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1031       line_ptr += 1;
1032     }
1033
1034   /* Read directory table.  */
1035   while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1036     {
1037       line_ptr += bytes_read;
1038
1039       if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1040         {
1041           amt = table->num_dirs + DIR_ALLOC_CHUNK;
1042           amt *= sizeof (char *);
1043           table->dirs = (char **) bfd_realloc (table->dirs, amt);
1044           if (! table->dirs)
1045             return 0;
1046         }
1047
1048       table->dirs[table->num_dirs++] = cur_dir;
1049     }
1050
1051   line_ptr += bytes_read;
1052
1053   /* Read file name table.  */
1054   while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1055     {
1056       line_ptr += bytes_read;
1057
1058       if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1059         {
1060           amt = table->num_files + FILE_ALLOC_CHUNK;
1061           amt *= sizeof (struct fileinfo);
1062           table->files = (struct fileinfo *) bfd_realloc (table->files, amt);
1063           if (! table->files)
1064             return 0;
1065         }
1066
1067       table->files[table->num_files].name = cur_file;
1068       table->files[table->num_files].dir =
1069         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1070       line_ptr += bytes_read;
1071       table->files[table->num_files].time =
1072         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1073       line_ptr += bytes_read;
1074       table->files[table->num_files].size =
1075         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1076       line_ptr += bytes_read;
1077       table->num_files++;
1078     }
1079
1080   line_ptr += bytes_read;
1081
1082   /* Read the statement sequences until there's nothing left.  */
1083   while (line_ptr < line_end)
1084     {
1085       /* State machine registers.  */
1086       bfd_vma address = 0;
1087       char * filename = concat_filename (table, 1);
1088       unsigned int line = 1;
1089       unsigned int column = 0;
1090       int is_stmt = lh.default_is_stmt;
1091       int basic_block = 0;
1092       int end_sequence = 0;
1093       /* eraxxon@alumni.rice.edu: Against the DWARF2 specs, some
1094          compilers generate address sequences that are wildly out of
1095          order using DW_LNE_set_address (e.g. Intel C++ 6.0 compiler
1096          for ia64-Linux).  Thus, to determine the low and high
1097          address, we must compare on every DW_LNS_copy, etc.  */
1098       bfd_vma low_pc  = 0;
1099       bfd_vma high_pc = 0;
1100
1101       /* Decode the table.  */
1102       while (! end_sequence)
1103         {
1104           op_code = read_1_byte (abfd, line_ptr);
1105           line_ptr += 1;
1106
1107           if (op_code >= lh.opcode_base)
1108             {
1109               /* Special operand.  */
1110               adj_opcode = op_code - lh.opcode_base;
1111               address += (adj_opcode / lh.line_range)
1112                 * lh.minimum_instruction_length;
1113               line += lh.line_base + (adj_opcode % lh.line_range);
1114               /* Append row to matrix using current values.  */
1115               add_line_info (table, address, filename, line, column, 0);
1116               basic_block = 1;
1117               if (low_pc == 0 || address < low_pc)
1118                 low_pc = address;
1119               if (address > high_pc)
1120                 high_pc = address;
1121             }
1122           else switch (op_code)
1123             {
1124             case DW_LNS_extended_op:
1125               /* Ignore length.  */
1126               line_ptr += 1;
1127               extended_op = read_1_byte (abfd, line_ptr);
1128               line_ptr += 1;
1129
1130               switch (extended_op)
1131                 {
1132                 case DW_LNE_end_sequence:
1133                   end_sequence = 1;
1134                   add_line_info (table, address, filename, line, column,
1135                                  end_sequence);
1136                   arange_add (unit, low_pc, high_pc);
1137                   if (low_pc == 0 || address < low_pc)
1138                     low_pc = address;
1139                   if (address > high_pc)
1140                     high_pc = address;
1141                   arange_add (unit, low_pc, address);
1142                   break;
1143                 case DW_LNE_set_address:
1144                   address = read_address (unit, line_ptr);
1145                   line_ptr += unit->addr_size;
1146                   break;
1147                 case DW_LNE_define_file:
1148                   cur_file = read_string (abfd, line_ptr, &bytes_read);
1149                   line_ptr += bytes_read;
1150                   if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1151                     {
1152                       amt = table->num_files + FILE_ALLOC_CHUNK;
1153                       amt *= sizeof (struct fileinfo);
1154                       table->files =
1155                         (struct fileinfo *) bfd_realloc (table->files, amt);
1156                       if (! table->files)
1157                         return 0;
1158                     }
1159                   table->files[table->num_files].name = cur_file;
1160                   table->files[table->num_files].dir =
1161                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1162                   line_ptr += bytes_read;
1163                   table->files[table->num_files].time =
1164                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1165                   line_ptr += bytes_read;
1166                   table->files[table->num_files].size =
1167                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1168                   line_ptr += bytes_read;
1169                   table->num_files++;
1170                   break;
1171                 default:
1172                   (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1173                   bfd_set_error (bfd_error_bad_value);
1174                   return 0;
1175                 }
1176               break;
1177             case DW_LNS_copy:
1178               add_line_info (table, address, filename, line, column, 0);
1179               basic_block = 0;
1180               if (low_pc == 0 || address < low_pc)
1181                 low_pc = address;
1182               if (address > high_pc)
1183                 high_pc = address;
1184               break;
1185             case DW_LNS_advance_pc:
1186               address += lh.minimum_instruction_length
1187                 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1188               line_ptr += bytes_read;
1189               break;
1190             case DW_LNS_advance_line:
1191               line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1192               line_ptr += bytes_read;
1193               break;
1194             case DW_LNS_set_file:
1195               {
1196                 unsigned int file;
1197
1198                 /* The file and directory tables are 0
1199                    based, the references are 1 based.  */
1200                 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1201                 line_ptr += bytes_read;
1202                 filename = concat_filename (table, file);
1203                 break;
1204               }
1205             case DW_LNS_set_column:
1206               column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1207               line_ptr += bytes_read;
1208               break;
1209             case DW_LNS_negate_stmt:
1210               is_stmt = (!is_stmt);
1211               break;
1212             case DW_LNS_set_basic_block:
1213               basic_block = 1;
1214               break;
1215             case DW_LNS_const_add_pc:
1216               address += lh.minimum_instruction_length
1217                       * ((255 - lh.opcode_base) / lh.line_range);
1218               break;
1219             case DW_LNS_fixed_advance_pc:
1220               address += read_2_bytes (abfd, line_ptr);
1221               line_ptr += 2;
1222               break;
1223             default:
1224               {
1225                 int i;
1226                 /* Unknown standard opcode, ignore it.  */
1227                 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1228                   {
1229                     (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1230                     line_ptr += bytes_read;
1231                   }
1232               }
1233             }
1234         }
1235     }
1236
1237   return table;
1238 }
1239
1240 /* If ADDR is within TABLE set the output parameters and return true,
1241    otherwise return false.  The output parameters, FILENAME_PTR and
1242    LINENUMBER_PTR, are pointers to the objects to be filled in.  */
1243
1244 static boolean
1245 lookup_address_in_line_info_table (table, addr, function, filename_ptr,
1246                                    linenumber_ptr)
1247      struct line_info_table* table;
1248      bfd_vma addr;
1249      struct funcinfo *function;
1250      const char **filename_ptr;
1251      unsigned int *linenumber_ptr;
1252 {
1253   struct line_info* next_line = table->last_line;
1254   struct line_info* each_line;
1255
1256   if (!next_line)
1257     return false;
1258
1259   each_line = next_line->prev_line;
1260
1261   while (each_line && next_line)
1262     {
1263       if (!each_line->end_sequence
1264           && addr >= each_line->address && addr < next_line->address)
1265         {
1266           /* If this line appears to span functions, and addr is in the
1267              later function, return the first line of that function instead
1268              of the last line of the earlier one.  This check is for GCC
1269              2.95, which emits the first line number for a function late.  */
1270           if (function != NULL
1271               && each_line->address < function->low
1272               && next_line->address > function->low)
1273             {
1274               *filename_ptr = next_line->filename;
1275               *linenumber_ptr = next_line->line;
1276             }
1277           else
1278             {
1279               *filename_ptr = each_line->filename;
1280               *linenumber_ptr = each_line->line;
1281             }
1282           return true;
1283         }
1284       next_line = each_line;
1285       each_line = each_line->prev_line;
1286     }
1287
1288   /* At this point each_line is NULL but next_line is not.  If we found the
1289      containing function in this compilation unit, return the first line we
1290      have a number for.  This is also for compatibility with GCC 2.95.  */
1291   if (function != NULL)
1292     {
1293       *filename_ptr = next_line->filename;
1294       *linenumber_ptr = next_line->line;
1295       return true;
1296     }
1297
1298   return false;
1299 }
1300
1301 /* Function table functions.  */
1302
1303 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true.  */
1304
1305 static boolean
1306 lookup_address_in_function_table (table, addr, function_ptr,
1307                                   functionname_ptr)
1308      struct funcinfo* table;
1309      bfd_vma addr;
1310      struct funcinfo** function_ptr;
1311      const char **functionname_ptr;
1312 {
1313   struct funcinfo* each_func;
1314
1315   for (each_func = table;
1316        each_func;
1317        each_func = each_func->prev_func)
1318     {
1319       if (addr >= each_func->low && addr < each_func->high)
1320         {
1321           *functionname_ptr = each_func->name;
1322           *function_ptr = each_func;
1323           return true;
1324         }
1325     }
1326
1327   return false;
1328 }
1329
1330 /* DWARF2 Compilation unit functions.  */
1331
1332 /* Scan over each die in a comp. unit looking for functions to add
1333    to the function table.  */
1334
1335 static boolean
1336 scan_unit_for_functions (unit)
1337      struct comp_unit *unit;
1338 {
1339   bfd *abfd = unit->abfd;
1340   char *info_ptr = unit->first_child_die_ptr;
1341   int nesting_level = 1;
1342
1343   while (nesting_level)
1344     {
1345       unsigned int abbrev_number, bytes_read, i;
1346       struct abbrev_info *abbrev;
1347       struct attribute attr;
1348       struct funcinfo *func;
1349       char* name = 0;
1350
1351       abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1352       info_ptr += bytes_read;
1353
1354       if (! abbrev_number)
1355         {
1356           nesting_level--;
1357           continue;
1358         }
1359
1360       abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1361       if (! abbrev)
1362         {
1363           (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1364                              abbrev_number);
1365           bfd_set_error (bfd_error_bad_value);
1366           return false;
1367         }
1368
1369       if (abbrev->tag == DW_TAG_subprogram)
1370         {
1371           bfd_size_type amt = sizeof (struct funcinfo);
1372           func = (struct funcinfo *) bfd_zalloc (abfd, amt);
1373           func->prev_func = unit->function_table;
1374           unit->function_table = func;
1375         }
1376       else
1377         func = NULL;
1378
1379       for (i = 0; i < abbrev->num_attrs; ++i)
1380         {
1381           info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1382
1383           if (func)
1384             {
1385               switch (attr.name)
1386                 {
1387                 case DW_AT_name:
1388
1389                   name = DW_STRING (&attr);
1390
1391                   /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
1392                   if (func->name == NULL)
1393                     func->name = DW_STRING (&attr);
1394                   break;
1395
1396                 case DW_AT_MIPS_linkage_name:
1397                   func->name = DW_STRING (&attr);
1398                   break;
1399
1400                 case DW_AT_low_pc:
1401                   func->low = DW_ADDR (&attr);
1402                   break;
1403
1404                 case DW_AT_high_pc:
1405                   func->high = DW_ADDR (&attr);
1406                   break;
1407
1408                 default:
1409                   break;
1410                 }
1411             }
1412           else
1413             {
1414               switch (attr.name)
1415                 {
1416                 case DW_AT_name:
1417                   name = DW_STRING (&attr);
1418                   break;
1419
1420                 default:
1421                   break;
1422                 }
1423             }
1424         }
1425
1426       if (abbrev->has_children)
1427         nesting_level++;
1428     }
1429
1430   return true;
1431 }
1432
1433 /* Look for a RELA relocation to be applied on OFFSET of section SEC,
1434    and return the addend if such a relocation is found.  Since this is
1435    only used to find relocations referring to the .debug_abbrev
1436    section, we make sure the relocation refers to this section, but
1437    this is not strictly necessary, and it can probably be safely
1438    removed if needed.  However, it is important to note that this
1439    function only returns the addend, it doesn't serve the purpose of
1440    applying a generic relocation.
1441
1442    If no suitable relocation is found, or if it is not a real RELA
1443    relocation, this function returns 0.  */
1444
1445 static bfd_vma
1446 find_rela_addend (abfd, sec, offset, syms)
1447      bfd* abfd;
1448      asection* sec;
1449      bfd_size_type offset;
1450      asymbol** syms;
1451 {
1452   long reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
1453   arelent **relocs = NULL;
1454   long reloc_count, relc;
1455
1456   if (reloc_size <= 0)
1457     return 0;
1458
1459   relocs = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
1460   if (relocs == NULL)
1461     return 0;
1462
1463   reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, syms);
1464
1465   if (reloc_count <= 0)
1466     {
1467       free (relocs);
1468       return 0;
1469     }
1470
1471   for (relc = 0; relc < reloc_count; relc++)
1472     if (relocs[relc]->address == offset
1473         && (*relocs[relc]->sym_ptr_ptr)->flags & BSF_SECTION_SYM
1474         && strcmp ((*relocs[relc]->sym_ptr_ptr)->name,
1475                    ".debug_abbrev") == 0)
1476       {
1477         bfd_vma addend = (relocs[relc]->howto->partial_inplace
1478                           ? 0 : relocs[relc]->addend);
1479         free (relocs);
1480         return addend;
1481       }
1482
1483   free (relocs);
1484   return 0;
1485 }
1486
1487 /* Parse a DWARF2 compilation unit starting at INFO_PTR.  This
1488    includes the compilation unit header that proceeds the DIE's, but
1489    does not include the length field that preceeds each compilation
1490    unit header.  END_PTR points one past the end of this comp unit.
1491    OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1492
1493    This routine does not read the whole compilation unit; only enough
1494    to get to the line number information for the compilation unit.  */
1495
1496 static struct comp_unit *
1497 parse_comp_unit (abfd, stash, unit_length, offset_size)
1498      bfd* abfd;
1499      struct dwarf2_debug *stash;
1500      bfd_vma unit_length;
1501      unsigned int offset_size;
1502 {
1503   struct comp_unit* unit;
1504   unsigned int version;
1505   bfd_vma abbrev_offset = 0;
1506   unsigned int addr_size;
1507   struct abbrev_info** abbrevs;
1508   unsigned int abbrev_number, bytes_read, i;
1509   struct abbrev_info *abbrev;
1510   struct attribute attr;
1511   char *info_ptr = stash->info_ptr;
1512   char *end_ptr = info_ptr + unit_length;
1513   bfd_size_type amt;
1514   bfd_size_type off;
1515
1516   version = read_2_bytes (abfd, info_ptr);
1517   info_ptr += 2;
1518   BFD_ASSERT (offset_size == 4 || offset_size == 8);
1519   if (offset_size == 4)
1520     abbrev_offset = read_4_bytes (abfd, info_ptr);
1521   else
1522     abbrev_offset = read_8_bytes (abfd, info_ptr);
1523   /* The abbrev offset is generally a relocation pointing to
1524      .debug_abbrev+offset.  On RELA targets, we have to find the
1525      relocation and extract the addend to obtain the actual
1526      abbrev_offset, so do it here.  */
1527   off = info_ptr - stash->sec_info_ptr;
1528   abbrev_offset += find_rela_addend (abfd, stash->sec, off, stash->syms);
1529   info_ptr += offset_size;
1530   addr_size = read_1_byte (abfd, info_ptr);
1531   info_ptr += 1;
1532
1533   if (version != 2)
1534     {
1535       (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
1536       bfd_set_error (bfd_error_bad_value);
1537       return 0;
1538     }
1539
1540   if (addr_size > sizeof (bfd_vma))
1541     {
1542       (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1543                          addr_size,
1544                          (unsigned int) sizeof (bfd_vma));
1545       bfd_set_error (bfd_error_bad_value);
1546       return 0;
1547     }
1548
1549   if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1550     {
1551       (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
1552       bfd_set_error (bfd_error_bad_value);
1553       return 0;
1554     }
1555
1556   /* Read the abbrevs for this compilation unit into a table.  */
1557   abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
1558   if (! abbrevs)
1559       return 0;
1560
1561   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1562   info_ptr += bytes_read;
1563   if (! abbrev_number)
1564     {
1565       (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
1566                          abbrev_number);
1567       bfd_set_error (bfd_error_bad_value);
1568       return 0;
1569     }
1570
1571   abbrev = lookup_abbrev (abbrev_number, abbrevs);
1572   if (! abbrev)
1573     {
1574       (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1575                          abbrev_number);
1576       bfd_set_error (bfd_error_bad_value);
1577       return 0;
1578     }
1579
1580   amt = sizeof (struct comp_unit);
1581   unit = (struct comp_unit*) bfd_zalloc (abfd, amt);
1582   unit->abfd = abfd;
1583   unit->addr_size = addr_size;
1584   unit->offset_size = offset_size;
1585   unit->abbrevs = abbrevs;
1586   unit->end_ptr = end_ptr;
1587   unit->stash = stash;
1588
1589   for (i = 0; i < abbrev->num_attrs; ++i)
1590     {
1591       info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1592
1593       /* Store the data if it is of an attribute we want to keep in a
1594          partial symbol table.  */
1595       switch (attr.name)
1596         {
1597         case DW_AT_stmt_list:
1598           unit->stmtlist = 1;
1599           unit->line_offset = DW_UNSND (&attr);
1600           break;
1601
1602         case DW_AT_name:
1603           unit->name = DW_STRING (&attr);
1604           break;
1605
1606         case DW_AT_low_pc:
1607           unit->arange.low = DW_ADDR (&attr);
1608           break;
1609
1610         case DW_AT_high_pc:
1611           unit->arange.high = DW_ADDR (&attr);
1612           break;
1613
1614         case DW_AT_comp_dir:
1615           {
1616             char* comp_dir = DW_STRING (&attr);
1617             if (comp_dir)
1618               {
1619                 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1620                    directory, get rid of it.  */
1621                 char *cp = (char*) strchr (comp_dir, ':');
1622
1623                 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1624                   comp_dir = cp + 1;
1625               }
1626             unit->comp_dir = comp_dir;
1627             break;
1628           }
1629
1630         default:
1631           break;
1632         }
1633     }
1634
1635   unit->first_child_die_ptr = info_ptr;
1636   return unit;
1637 }
1638
1639 /* Return true if UNIT contains the address given by ADDR.  */
1640
1641 static boolean
1642 comp_unit_contains_address (unit, addr)
1643      struct comp_unit* unit;
1644      bfd_vma addr;
1645 {
1646   struct arange *arange;
1647
1648   if (unit->error)
1649     return 0;
1650
1651   arange = &unit->arange;
1652   do
1653     {
1654       if (addr >= arange->low && addr < arange->high)
1655         return 1;
1656       arange = arange->next;
1657     }
1658   while (arange);
1659
1660   return 0;
1661 }
1662
1663 /* If UNIT contains ADDR, set the output parameters to the values for
1664    the line containing ADDR.  The output parameters, FILENAME_PTR,
1665    FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1666    to be filled in.
1667
1668    Return true of UNIT contains ADDR, and no errors were encountered;
1669    false otherwise.  */
1670
1671 static boolean
1672 comp_unit_find_nearest_line (unit, addr, filename_ptr, functionname_ptr,
1673                              linenumber_ptr, stash)
1674      struct comp_unit* unit;
1675      bfd_vma addr;
1676      const char **filename_ptr;
1677      const char **functionname_ptr;
1678      unsigned int *linenumber_ptr;
1679      struct dwarf2_debug *stash;
1680 {
1681   boolean line_p;
1682   boolean func_p;
1683   struct funcinfo *function;
1684
1685   if (unit->error)
1686     return false;
1687
1688   if (! unit->line_table)
1689     {
1690       if (! unit->stmtlist)
1691         {
1692           unit->error = 1;
1693           return false;
1694         }
1695
1696       unit->line_table = decode_line_info (unit, stash);
1697
1698       if (! unit->line_table)
1699         {
1700           unit->error = 1;
1701           return false;
1702         }
1703
1704       if (unit->first_child_die_ptr < unit->end_ptr
1705           && ! scan_unit_for_functions (unit))
1706         {
1707           unit->error = 1;
1708           return false;
1709         }
1710     }
1711
1712   function = NULL;
1713   func_p = lookup_address_in_function_table (unit->function_table, addr,
1714                                              &function, functionname_ptr);
1715   line_p = lookup_address_in_line_info_table (unit->line_table, addr,
1716                                               function, filename_ptr,
1717                                               linenumber_ptr);
1718   return line_p || func_p;
1719 }
1720
1721 /* Locate a section in a BFD containing debugging info.  The search starts
1722    from the section after AFTER_SEC, or from the first section in the BFD if
1723    AFTER_SEC is NULL.  The search works by examining the names of the
1724    sections.  There are two permissiable names.  The first is .debug_info.
1725    This is the standard DWARF2 name.  The second is a prefix .gnu.linkonce.wi.
1726    This is a variation on the .debug_info section which has a checksum
1727    describing the contents appended onto the name.  This allows the linker to
1728    identify and discard duplicate debugging sections for different
1729    compilation units.  */
1730 #define DWARF2_DEBUG_INFO ".debug_info"
1731 #define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
1732
1733 static asection *
1734 find_debug_info (abfd, after_sec)
1735      bfd * abfd;
1736      asection * after_sec;
1737 {
1738   asection * msec;
1739
1740   if (after_sec)
1741     msec = after_sec->next;
1742   else
1743     msec = abfd->sections;
1744
1745   while (msec)
1746     {
1747       if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
1748         return msec;
1749
1750       if (strncmp (msec->name, GNU_LINKONCE_INFO, strlen (GNU_LINKONCE_INFO)) == 0)
1751         return msec;
1752
1753       msec = msec->next;
1754     }
1755
1756   return NULL;
1757 }
1758
1759 /* The DWARF2 version of find_nearest line.  Return true if the line
1760    is found without error.  ADDR_SIZE is the number of bytes in the
1761    initial .debug_info length field and in the abbreviation offset.
1762    You may use zero to indicate that the default value should be
1763    used.  */
1764
1765 boolean
1766 _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
1767                                filename_ptr, functionname_ptr,
1768                                linenumber_ptr, addr_size, pinfo)
1769      bfd *abfd;
1770      asection *section;
1771      asymbol **symbols;
1772      bfd_vma offset;
1773      const char **filename_ptr;
1774      const char **functionname_ptr;
1775      unsigned int *linenumber_ptr;
1776      unsigned int addr_size;
1777      PTR *pinfo;
1778 {
1779   /* Read each compilation unit from the section .debug_info, and check
1780      to see if it contains the address we are searching for.  If yes,
1781      lookup the address, and return the line number info.  If no, go
1782      on to the next compilation unit.
1783
1784      We keep a list of all the previously read compilation units, and
1785      a pointer to the next un-read compilation unit.  Check the
1786      previously read units before reading more.  */
1787   struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
1788
1789   /* What address are we looking for?  */
1790   bfd_vma addr = offset + section->vma;
1791
1792   struct comp_unit* each;
1793
1794   *filename_ptr = NULL;
1795   *functionname_ptr = NULL;
1796   *linenumber_ptr = 0;
1797
1798   /* The DWARF2 spec says that the initial length field, and the
1799      offset of the abbreviation table, should both be 4-byte values.
1800      However, some compilers do things differently.  */
1801   if (addr_size == 0)
1802     addr_size = 4;
1803   BFD_ASSERT (addr_size == 4 || addr_size == 8);
1804
1805   if (! stash)
1806     {
1807       bfd_size_type total_size;
1808       asection *msec;
1809       bfd_size_type amt = sizeof (struct dwarf2_debug);
1810
1811       stash = (struct dwarf2_debug*) bfd_zalloc (abfd, amt);
1812       if (! stash)
1813         return false;
1814
1815       *pinfo = (PTR) stash;
1816
1817       msec = find_debug_info (abfd, NULL);
1818       if (! msec)
1819         /* No dwarf2 info.  Note that at this point the stash
1820            has been allocated, but contains zeros, this lets
1821            future calls to this function fail quicker.  */
1822          return false;
1823
1824       /* There can be more than one DWARF2 info section in a BFD these days.
1825          Read them all in and produce one large stash.  We do this in two
1826          passes - in the first pass we just accumulate the section sizes.
1827          In the second pass we read in the section's contents.  The allows
1828          us to avoid reallocing the data as we add sections to the stash.  */
1829       for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
1830         total_size += msec->_raw_size;
1831
1832       stash->info_ptr = (char *) bfd_alloc (abfd, total_size);
1833       if (stash->info_ptr == NULL)
1834         return false;
1835
1836       stash->info_ptr_end = stash->info_ptr;
1837
1838       for (msec = find_debug_info (abfd, NULL);
1839            msec;
1840            msec = find_debug_info (abfd, msec))
1841         {
1842           bfd_size_type size;
1843           bfd_size_type start;
1844
1845           size = msec->_raw_size;
1846           if (size == 0)
1847             continue;
1848
1849           start = stash->info_ptr_end - stash->info_ptr;
1850
1851           if (! bfd_get_section_contents (abfd, msec, stash->info_ptr + start,
1852                                           (bfd_vma) 0, size))
1853             continue;
1854
1855           stash->info_ptr_end = stash->info_ptr + start + size;
1856         }
1857
1858       BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
1859
1860       stash->sec = find_debug_info (abfd, NULL);
1861       stash->sec_info_ptr = stash->info_ptr;
1862       stash->syms = symbols;
1863     }
1864
1865   /* FIXME: There is a problem with the contents of the
1866      .debug_info section.  The 'low' and 'high' addresses of the
1867      comp_units are computed by relocs against symbols in the
1868      .text segment.  We need these addresses in order to determine
1869      the nearest line number, and so we have to resolve the
1870      relocs.  There is a similar problem when the .debug_line
1871      section is processed as well (e.g., there may be relocs
1872      against the operand of the DW_LNE_set_address operator).
1873
1874      Unfortunately getting hold of the reloc information is hard...
1875
1876      For now, this means that disassembling object files (as
1877      opposed to fully executables) does not always work as well as
1878      we would like.  */
1879
1880   /* A null info_ptr indicates that there is no dwarf2 info
1881      (or that an error occured while setting up the stash).  */
1882   if (! stash->info_ptr)
1883     return false;
1884
1885   /* Check the previously read comp. units first.  */
1886   for (each = stash->all_comp_units; each; each = each->next_unit)
1887     if (comp_unit_contains_address (each, addr))
1888       return comp_unit_find_nearest_line (each, addr, filename_ptr,
1889                                           functionname_ptr, linenumber_ptr,
1890                                           stash);
1891
1892   /* Read each remaining comp. units checking each as they are read.  */
1893   while (stash->info_ptr < stash->info_ptr_end)
1894     {
1895       bfd_vma length;
1896       boolean found;
1897       unsigned int offset_size = addr_size;
1898
1899       if (addr_size == 4)
1900         {
1901           length = read_4_bytes (abfd, stash->info_ptr);
1902           if (length == 0xffffffff)
1903             {
1904               offset_size = 8;
1905               length = read_8_bytes (abfd, stash->info_ptr + 4);
1906               stash->info_ptr += 8;
1907             }
1908           else if (length == 0)
1909             {
1910               /* Handle (non-standard) 64-bit DWARF2 formats.  */
1911               offset_size = 8;
1912               length = read_4_bytes (abfd, stash->info_ptr + 4);
1913               stash->info_ptr += 4;
1914             }
1915         }
1916       else
1917         length = read_8_bytes (abfd, stash->info_ptr);
1918       stash->info_ptr += addr_size;
1919
1920       if (length > 0)
1921         {
1922           each = parse_comp_unit (abfd, stash, length, offset_size);
1923           stash->info_ptr += length;
1924
1925           if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
1926               == stash->sec->_raw_size)
1927             {
1928               stash->sec = find_debug_info (abfd, stash->sec);
1929               stash->sec_info_ptr = stash->info_ptr;
1930             }
1931
1932           if (each)
1933             {
1934               each->next_unit = stash->all_comp_units;
1935               stash->all_comp_units = each;
1936
1937               /* DW_AT_low_pc and DW_AT_high_pc are optional for
1938                  compilation units.  If we don't have them (i.e.,
1939                  unit->high == 0), we need to consult the line info
1940                  table to see if a compilation unit contains the given
1941                  address.  */
1942               if (each->arange.high > 0)
1943                 {
1944                   if (comp_unit_contains_address (each, addr))
1945                     return comp_unit_find_nearest_line (each, addr,
1946                                                        filename_ptr,
1947                                                        functionname_ptr,
1948                                                        linenumber_ptr,
1949                                                        stash);
1950                 }
1951               else
1952                 {
1953                   found = comp_unit_find_nearest_line (each, addr,
1954                                                        filename_ptr,
1955                                                        functionname_ptr,
1956                                                        linenumber_ptr,
1957                                                        stash);
1958                   if (found)
1959                     return true;
1960                 }
1961             }
1962         }
1963     }
1964
1965   return false;
1966 }