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
 860   else
 861     {
 862       char* dirname = (table->files[file - 1].dir
 863                        ? table->dirs[table->files[file - 1].dir - 1]
 864                        : table->comp_dir);
 865       return (char*) concat (dirname, "/", filename, NULL);
 866     }
 867 }
 868
 869 static void
 870 arange_add (unit, low_pc, high_pc)
 871      struct comp_unit *unit;
 872      bfd_vma low_pc;
 873      bfd_vma high_pc;
 874 {
 875   struct arange *arange;
 876
 877   /* First see if we can cheaply extend an existing range.  */
 878   arange = &unit->arange;
 879
 880   do
 881     {
 882       if (low_pc == arange->high)
 883         {
 884           arange->high = high_pc;
 885           return;
 886         }
 887       if (high_pc == arange->low)
 888         {
 889           arange->low = low_pc;
 890           return;
 891         }
 892       arange = arange->next;
 893     }
 894   while (arange);
 895
 896   if (unit->arange.high == 0)
 897     {
 898       /* This is the first address range: store it in unit->arange.  */
 899       unit->arange.next = 0;
 900       unit->arange.low = low_pc;
 901       unit->arange.high = high_pc;
 902       return;
 903     }
 904
 905   /* Need to allocate a new arange and insert it into the arange list.  */
 906   arange = bfd_zalloc (unit->abfd, (bfd_size_type) sizeof (*arange));
 907   arange->low = low_pc;
 908   arange->high = high_pc;
 909
 910   arange->next = unit->arange.next;
 911   unit->arange.next = arange;
 912 }
 913
 914 /* Decode the line number information for UNIT.  */
 915
 916 static struct line_info_table*
 917 decode_line_info (unit, stash)
 918      struct comp_unit *unit;
 919      struct dwarf2_debug *stash;
 920 {
 921   bfd *abfd = unit->abfd;
 922   struct line_info_table* table;
 923   char *line_ptr;
 924   char *line_end;
 925   struct line_head lh;
 926   unsigned int i, bytes_read, offset_size;
 927   char *cur_file, *cur_dir;
 928   unsigned char op_code, extended_op, adj_opcode;
 929   bfd_size_type amt;
 930
 931   if (! stash->dwarf_line_buffer)
 932     {
 933       asection *msec;
 934
 935       msec = bfd_get_section_by_name (abfd, ".debug_line");
 936       if (! msec)
 937         {
 938           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
 939           bfd_set_error (bfd_error_bad_value);
 940           return 0;
 941         }
 942
 943       stash->dwarf_line_size = msec->_raw_size;
 944       stash->dwarf_line_buffer = (char *) bfd_alloc (abfd, msec->_raw_size);
 945       if (! stash->dwarf_line_buffer)
 946         return 0;
 947
 948       if (! bfd_get_section_contents (abfd, msec, stash->dwarf_line_buffer,
 949                                       (bfd_vma) 0, msec->_raw_size))
 950         return 0;
 951
 952       /* FIXME: We ought to apply the relocs against this section before
 953          we process it...  */
 954     }
 955
 956   /* Since we are using un-relocated data, it is possible to get a bad value
 957      for the line_offset.  Validate it here so that we won't get a segfault
 958      below.  */
 959   if (unit->line_offset >= stash->dwarf_line_size)
 960     {
 961       (*_bfd_error_handler) (_("Dwarf Error: Line offset (%lu) greater than or equal to .debug_line size (%lu)."),
 962                              unit->line_offset, stash->dwarf_line_size);
 963       bfd_set_error (bfd_error_bad_value);
 964       return 0;
 965     }
 966
 967   amt = sizeof (struct line_info_table);
 968   table = (struct line_info_table*) bfd_alloc (abfd, amt);
 969   table->abfd = abfd;
 970   table->comp_dir = unit->comp_dir;
 971
 972   table->num_files = 0;
 973   table->files = NULL;
 974
 975   table->num_dirs = 0;
 976   table->dirs = NULL;
 977
 978   table->files = NULL;
 979   table->last_line = NULL;
 980
 981   line_ptr = stash->dwarf_line_buffer + unit->line_offset;
 982
 983   /* Read in the prologue.  */
 984   if (unit->addr_size == 4)
 985     {
 986       lh.total_length = read_4_bytes (abfd, line_ptr);
 987       line_ptr += 4;
 988       offset_size = 4;
 989     }
 990   else
 991     {
 992       BFD_ASSERT (unit->addr_size == 8);
 993       lh.total_length = read_8_bytes (abfd, line_ptr);
 994       line_ptr += 8;
 995       offset_size = 8;
 996     }
 997
 998   if (lh.total_length == 0xffffffff)
 999     {
1000       lh.total_length = read_8_bytes (abfd, line_ptr);
1001       line_ptr += 8;
1002       offset_size = 8;
1003     }
1004   line_end = line_ptr + lh.total_length;
1005   lh.version = read_2_bytes (abfd, line_ptr);
1006   line_ptr += 2;
1007   if (offset_size == 4)
1008     lh.prologue_length = read_4_bytes (abfd, line_ptr);
1009   else
1010     lh.prologue_length = read_8_bytes (abfd, line_ptr);
1011   line_ptr += offset_size;
1012   lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
1013   line_ptr += 1;
1014   lh.default_is_stmt = read_1_byte (abfd, line_ptr);
1015   line_ptr += 1;
1016   lh.line_base = read_1_signed_byte (abfd, line_ptr);
1017   line_ptr += 1;
1018   lh.line_range = read_1_byte (abfd, line_ptr);
1019   line_ptr += 1;
1020   lh.opcode_base = read_1_byte (abfd, line_ptr);
1021   line_ptr += 1;
1022   amt = lh.opcode_base * sizeof (unsigned char);
1023   lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
1024
1025   lh.standard_opcode_lengths[0] = 1;
1026
1027   for (i = 1; i < lh.opcode_base; ++i)
1028     {
1029       lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
1030       line_ptr += 1;
1031     }
1032
1033   /* Read directory table.  */
1034   while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1035     {
1036       line_ptr += bytes_read;
1037
1038       if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
1039         {
1040           amt = table->num_dirs + DIR_ALLOC_CHUNK;
1041           amt *= sizeof (char *);
1042           table->dirs = (char **) bfd_realloc (table->dirs, amt);
1043           if (! table->dirs)
1044             return 0;
1045         }
1046
1047       table->dirs[table->num_dirs++] = cur_dir;
1048     }
1049
1050   line_ptr += bytes_read;
1051
1052   /* Read file name table.  */
1053   while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
1054     {
1055       line_ptr += bytes_read;
1056
1057       if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1058         {
1059           amt = table->num_files + FILE_ALLOC_CHUNK;
1060           amt *= sizeof (struct fileinfo);
1061           table->files = (struct fileinfo *) bfd_realloc (table->files, amt);
1062           if (! table->files)
1063             return 0;
1064         }
1065
1066       table->files[table->num_files].name = cur_file;
1067       table->files[table->num_files].dir =
1068         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1069       line_ptr += bytes_read;
1070       table->files[table->num_files].time =
1071         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1072       line_ptr += bytes_read;
1073       table->files[table->num_files].size =
1074         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1075       line_ptr += bytes_read;
1076       table->num_files++;
1077     }
1078
1079   line_ptr += bytes_read;
1080
1081   /* Read the statement sequences until there's nothing left.  */
1082   while (line_ptr < line_end)
1083     {
1084       /* State machine registers.  */
1085       bfd_vma address = 0;
1086       char* filename = concat_filename (table, 1);
1087       unsigned int line = 1;
1088       unsigned int column = 0;
1089       int is_stmt = lh.default_is_stmt;
1090       int basic_block = 0;
1091       int end_sequence = 0, need_low_pc = 1;
1092       bfd_vma low_pc = 0;
1093
1094       /* Decode the table.  */
1095       while (! end_sequence)
1096         {
1097           op_code = read_1_byte (abfd, line_ptr);
1098           line_ptr += 1;
1099
1100           if (op_code >= lh.opcode_base)
1101             {           /* Special operand.  */
1102               adj_opcode = op_code - lh.opcode_base;
1103               address += (adj_opcode / lh.line_range)
1104                 * lh.minimum_instruction_length;
1105               line += lh.line_base + (adj_opcode % lh.line_range);
1106               /* Append row to matrix using current values.  */
1107               add_line_info (table, address, filename, line, column, 0);
1108               basic_block = 1;
1109               if (need_low_pc)
1110                 {
1111                   need_low_pc = 0;
1112                   low_pc = address;
1113                 }
1114             }
1115           else switch (op_code)
1116             {
1117             case DW_LNS_extended_op:
1118               line_ptr += 1;    /* Ignore length.  */
1119               extended_op = read_1_byte (abfd, line_ptr);
1120               line_ptr += 1;
1121               switch (extended_op)
1122                 {
1123                 case DW_LNE_end_sequence:
1124                   end_sequence = 1;
1125                   add_line_info (table, address, filename, line, column,
1126                                  end_sequence);
1127                   if (need_low_pc)
1128                     {
1129                       need_low_pc = 0;
1130                       low_pc = address;
1131                     }
1132                   arange_add (unit, low_pc, address);
1133                   break;
1134                 case DW_LNE_set_address:
1135                   address = read_address (unit, line_ptr);
1136                   line_ptr += unit->addr_size;
1137                   break;
1138                 case DW_LNE_define_file:
1139                   cur_file = read_string (abfd, line_ptr, &bytes_read);
1140                   line_ptr += bytes_read;
1141                   if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
1142                     {
1143                       amt = table->num_files + FILE_ALLOC_CHUNK;
1144                       amt *= sizeof (struct fileinfo);
1145                       table->files =
1146                         (struct fileinfo *) bfd_realloc (table->files, amt);
1147                       if (! table->files)
1148                         return 0;
1149                     }
1150                   table->files[table->num_files].name = cur_file;
1151                   table->files[table->num_files].dir =
1152                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1153                   line_ptr += bytes_read;
1154                   table->files[table->num_files].time =
1155                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1156                   line_ptr += bytes_read;
1157                   table->files[table->num_files].size =
1158                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1159                   line_ptr += bytes_read;
1160                   table->num_files++;
1161                   break;
1162                 default:
1163                   (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
1164                   bfd_set_error (bfd_error_bad_value);
1165                   return 0;
1166                 }
1167               break;
1168             case DW_LNS_copy:
1169               add_line_info (table, address, filename, line, column, 0);
1170               basic_block = 0;
1171               if (need_low_pc)
1172                 {
1173                   need_low_pc = 0;
1174                   low_pc = address;
1175                 }
1176               break;
1177             case DW_LNS_advance_pc:
1178               address += lh.minimum_instruction_length
1179                 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1180               line_ptr += bytes_read;
1181               break;
1182             case DW_LNS_advance_line:
1183               line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
1184               line_ptr += bytes_read;
1185               break;
1186             case DW_LNS_set_file:
1187               {
1188                 unsigned int file;
1189
1190                 /* The file and directory tables are 0 based, the references
1191                    are 1 based.  */
1192                 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1193                 line_ptr += bytes_read;
1194                 filename = concat_filename (table, file);
1195                 break;
1196               }
1197             case DW_LNS_set_column:
1198               column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1199               line_ptr += bytes_read;
1200               break;
1201             case DW_LNS_negate_stmt:
1202               is_stmt = (!is_stmt);
1203               break;
1204             case DW_LNS_set_basic_block:
1205               basic_block = 1;
1206               break;
1207             case DW_LNS_const_add_pc:
1208               address += lh.minimum_instruction_length
1209                       * ((255 - lh.opcode_base) / lh.line_range);
1210               break;
1211             case DW_LNS_fixed_advance_pc:
1212               address += read_2_bytes (abfd, line_ptr);
1213               line_ptr += 2;
1214               break;
1215             default:
1216               {  /* Unknown standard opcode, ignore it.  */
1217                 int i;
1218                 for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
1219                   {
1220                     (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
1221                     line_ptr += bytes_read;
1222                   }
1223               }
1224             }
1225         }
1226     }
1227
1228   return table;
1229 }
1230
1231 /* If ADDR is within TABLE set the output parameters and return true,
1232    otherwise return false.  The output parameters, FILENAME_PTR and
1233    LINENUMBER_PTR, are pointers to the objects to be filled in.  */
1234
1235 static boolean
1236 lookup_address_in_line_info_table (table,
1237                                    addr,
1238                                    function,
1239                                    filename_ptr,
1240                                    linenumber_ptr)
1241      struct line_info_table* table;
1242      bfd_vma addr;
1243      struct funcinfo *function;
1244      const char **filename_ptr;
1245      unsigned int *linenumber_ptr;
1246 {
1247   struct line_info* next_line = table->last_line;
1248   struct line_info* each_line;
1249
1250   if (!next_line)
1251     return false;
1252
1253   each_line = next_line->prev_line;
1254
1255   while (each_line && next_line)
1256     {
1257       if (!each_line->end_sequence
1258           && addr >= each_line->address && addr < next_line->address)
1259         {
1260           /* If this line appears to span functions, and addr is in the
1261              later function, return the first line of that function instead
1262              of the last line of the earlier one.  This check is for GCC
1263              2.95, which emits the first line number for a function late.  */
1264           if (function != NULL
1265               && each_line->address < function->low
1266               && next_line->address > function->low)
1267             {
1268               *filename_ptr = next_line->filename;
1269               *linenumber_ptr = next_line->line;
1270             }
1271           else
1272             {
1273               *filename_ptr = each_line->filename;
1274               *linenumber_ptr = each_line->line;
1275             }
1276           return true;
1277         }
1278       next_line = each_line;
1279       each_line = each_line->prev_line;
1280     }
1281
1282   /* At this point each_line is NULL but next_line is not.  If we found the
1283      containing function in this compilation unit, return the first line we
1284      have a number for.  This is also for compatibility with GCC 2.95.  */
1285   if (function != NULL)
1286     {
1287       *filename_ptr = next_line->filename;
1288       *linenumber_ptr = next_line->line;
1289       return true;
1290     }
1291
1292   return false;
1293 }
1294
1295 /* Function table functions.  */
1296
1297 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true.  */
1298
1299 static boolean
1300 lookup_address_in_function_table (table,
1301                                   addr,
1302                                   function_ptr,
1303                                   functionname_ptr)
1304      struct funcinfo* table;
1305      bfd_vma addr;
1306      struct funcinfo** function_ptr;
1307      const char **functionname_ptr;
1308 {
1309   struct funcinfo* each_func;
1310
1311   for (each_func = table;
1312        each_func;
1313        each_func = each_func->prev_func)
1314     {
1315       if (addr >= each_func->low && addr < each_func->high)
1316         {
1317           *functionname_ptr = each_func->name;
1318           *function_ptr = each_func;
1319           return true;
1320         }
1321     }
1322
1323   return false;
1324 }
1325
1326 /* DWARF2 Compilation unit functions.  */
1327
1328 /* Scan over each die in a comp. unit looking for functions to add
1329    to the function table.  */
1330
1331 static boolean
1332 scan_unit_for_functions (unit)
1333      struct comp_unit *unit;
1334 {
1335   bfd *abfd = unit->abfd;
1336   char *info_ptr = unit->first_child_die_ptr;
1337   int nesting_level = 1;
1338
1339   while (nesting_level)
1340     {
1341       unsigned int abbrev_number, bytes_read, i;
1342       struct abbrev_info *abbrev;
1343       struct attribute attr;
1344       struct funcinfo *func;
1345       char* name = 0;
1346
1347       abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1348       info_ptr += bytes_read;
1349
1350       if (! abbrev_number)
1351         {
1352           nesting_level--;
1353           continue;
1354         }
1355
1356       abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1357       if (! abbrev)
1358         {
1359           (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1360                              abbrev_number);
1361           bfd_set_error (bfd_error_bad_value);
1362           return false;
1363         }
1364
1365       if (abbrev->tag == DW_TAG_subprogram)
1366         {
1367           bfd_size_type amt = sizeof (struct funcinfo);
1368           func = (struct funcinfo *) bfd_zalloc (abfd, amt);
1369           func->prev_func = unit->function_table;
1370           unit->function_table = func;
1371         }
1372       else
1373         func = NULL;
1374
1375       for (i = 0; i < abbrev->num_attrs; ++i)
1376         {
1377           info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1378
1379           if (func)
1380             {
1381               switch (attr.name)
1382                 {
1383                 case DW_AT_name:
1384
1385                   name = DW_STRING (&attr);
1386
1387                   /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
1388                   if (func->name == NULL)
1389                     func->name = DW_STRING (&attr);
1390                   break;
1391
1392                 case DW_AT_MIPS_linkage_name:
1393                   func->name = DW_STRING (&attr);
1394                   break;
1395
1396                 case DW_AT_low_pc:
1397                   func->low = DW_ADDR (&attr);
1398                   break;
1399
1400                 case DW_AT_high_pc:
1401                   func->high = DW_ADDR (&attr);
1402                   break;
1403
1404                 default:
1405                   break;
1406                 }
1407             }
1408           else
1409             {
1410               switch (attr.name)
1411                 {
1412                 case DW_AT_name:
1413                   name = DW_STRING (&attr);
1414                   break;
1415
1416                 default:
1417                   break;
1418                 }
1419             }
1420         }
1421
1422       if (abbrev->has_children)
1423         nesting_level++;
1424     }
1425
1426   return true;
1427 }
1428
1429 /* Look for a RELA relocation to be applied on OFFSET of section SEC,
1430    and return the addend if such a relocation is found.  Since this is
1431    only used to find relocations referring to the .debug_abbrev
1432    section, we make sure the relocation refers to this section, but
1433    this is not strictly necessary, and it can probably be safely
1434    removed if needed.  However, it is important to note that this
1435    function only returns the addend, it doesn't serve the purpose of
1436    applying a generic relocation.
1437
1438    If no suitable relocation is found, or if it is not a real RELA
1439    relocation, this function returns 0.  */
1440
1441 static bfd_vma
1442 find_rela_addend (abfd, sec, offset, syms)
1443      bfd* abfd;
1444      asection* sec;
1445      bfd_size_type offset;
1446      asymbol** syms;
1447 {
1448   long reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
1449   arelent **relocs = NULL;
1450   long reloc_count, relc;
1451
1452   if (reloc_size <= 0)
1453     return 0;
1454
1455   relocs = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
1456   if (relocs == NULL)
1457     return 0;
1458
1459   reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, syms);
1460
1461   if (reloc_count <= 0)
1462     {
1463       free (relocs);
1464       return 0;
1465     }
1466
1467   for (relc = 0; relc < reloc_count; relc++)
1468     if (relocs[relc]->address == offset
1469         && (*relocs[relc]->sym_ptr_ptr)->flags & BSF_SECTION_SYM
1470         && strcmp ((*relocs[relc]->sym_ptr_ptr)->name,
1471                    ".debug_abbrev") == 0)
1472       {
1473         bfd_vma addend = (relocs[relc]->howto->partial_inplace
1474                           ? 0 : relocs[relc]->addend);
1475         free (relocs);
1476         return addend;
1477       }
1478
1479   free (relocs);
1480   return 0;
1481 }
1482
1483 /* Parse a DWARF2 compilation unit starting at INFO_PTR.  This
1484    includes the compilation unit header that proceeds the DIE's, but
1485    does not include the length field that preceeds each compilation
1486    unit header.  END_PTR points one past the end of this comp unit.
1487    OFFSET_SIZE is the size of DWARF2 offsets (either 4 or 8 bytes).
1488
1489    This routine does not read the whole compilation unit; only enough
1490    to get to the line number information for the compilation unit.  */
1491
1492 static struct comp_unit *
1493 parse_comp_unit (abfd, stash, unit_length, offset_size)
1494      bfd* abfd;
1495      struct dwarf2_debug *stash;
1496      bfd_vma unit_length;
1497      unsigned int offset_size;
1498 {
1499   struct comp_unit* unit;
1500   unsigned int version;
1501   bfd_vma abbrev_offset = 0;
1502   unsigned int addr_size;
1503   struct abbrev_info** abbrevs;
1504   unsigned int abbrev_number, bytes_read, i;
1505   struct abbrev_info *abbrev;
1506   struct attribute attr;
1507   char *info_ptr = stash->info_ptr;
1508   char *end_ptr = info_ptr + unit_length;
1509   bfd_size_type amt;
1510   bfd_size_type off;
1511
1512   version = read_2_bytes (abfd, info_ptr);
1513   info_ptr += 2;
1514   BFD_ASSERT (offset_size == 4 || offset_size == 8);
1515   if (offset_size == 4)
1516     abbrev_offset = read_4_bytes (abfd, info_ptr);
1517   else
1518     abbrev_offset = read_8_bytes (abfd, info_ptr);
1519   /* The abbrev offset is generally a relocation pointing to
1520      .debug_abbrev+offset.  On RELA targets, we have to find the
1521      relocation and extract the addend to obtain the actual
1522      abbrev_offset, so do it here.  */
1523   off = info_ptr - stash->sec_info_ptr;
1524   abbrev_offset += find_rela_addend (abfd, stash->sec, off, stash->syms);
1525   info_ptr += offset_size;
1526   addr_size = read_1_byte (abfd, info_ptr);
1527   info_ptr += 1;
1528
1529   if (version != 2)
1530     {
1531       (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%u', this reader only handles version 2 information."), version);
1532       bfd_set_error (bfd_error_bad_value);
1533       return 0;
1534     }
1535
1536   if (addr_size > sizeof (bfd_vma))
1537     {
1538       (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1539                          addr_size,
1540                          (unsigned int) sizeof (bfd_vma));
1541       bfd_set_error (bfd_error_bad_value);
1542       return 0;
1543     }
1544
1545   if (addr_size != 2 && addr_size != 4 && addr_size != 8)
1546     {
1547       (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
1548       bfd_set_error (bfd_error_bad_value);
1549       return 0;
1550     }
1551
1552   /* Read the abbrevs for this compilation unit into a table.  */
1553   abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
1554   if (! abbrevs)
1555       return 0;
1556
1557   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1558   info_ptr += bytes_read;
1559   if (! abbrev_number)
1560     {
1561       (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %u."),
1562                          abbrev_number);
1563       bfd_set_error (bfd_error_bad_value);
1564       return 0;
1565     }
1566
1567   abbrev = lookup_abbrev (abbrev_number, abbrevs);
1568   if (! abbrev)
1569     {
1570       (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %u."),
1571                          abbrev_number);
1572       bfd_set_error (bfd_error_bad_value);
1573       return 0;
1574     }
1575
1576   amt = sizeof (struct comp_unit);
1577   unit = (struct comp_unit*) bfd_zalloc (abfd, amt);
1578   unit->abfd = abfd;
1579   unit->addr_size = addr_size;
1580   unit->offset_size = offset_size;
1581   unit->abbrevs = abbrevs;
1582   unit->end_ptr = end_ptr;
1583   unit->stash = stash;
1584
1585   for (i = 0; i < abbrev->num_attrs; ++i)
1586     {
1587       info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1588
1589       /* Store the data if it is of an attribute we want to keep in a
1590          partial symbol table.  */
1591       switch (attr.name)
1592         {
1593         case DW_AT_stmt_list:
1594           unit->stmtlist = 1;
1595           unit->line_offset = DW_UNSND (&attr);
1596           break;
1597
1598         case DW_AT_name:
1599           unit->name = DW_STRING (&attr);
1600           break;
1601
1602         case DW_AT_low_pc:
1603           unit->arange.low = DW_ADDR (&attr);
1604           break;
1605
1606         case DW_AT_high_pc:
1607           unit->arange.high = DW_ADDR (&attr);
1608           break;
1609
1610         case DW_AT_comp_dir:
1611           {
1612             char* comp_dir = DW_STRING (&attr);
1613             if (comp_dir)
1614               {
1615                 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1616                    directory, get rid of it.  */
1617                 char *cp = (char*) strchr (comp_dir, ':');
1618
1619                 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1620                   comp_dir = cp + 1;
1621               }
1622             unit->comp_dir = comp_dir;
1623             break;
1624           }
1625
1626         default:
1627           break;
1628         }
1629     }
1630
1631   unit->first_child_die_ptr = info_ptr;
1632   return unit;
1633 }
1634
1635 /* Return true if UNIT contains the address given by ADDR.  */
1636
1637 static boolean
1638 comp_unit_contains_address (unit, addr)
1639      struct comp_unit* unit;
1640      bfd_vma addr;
1641 {
1642   struct arange *arange;
1643
1644   if (unit->error)
1645     return 0;
1646
1647   arange = &unit->arange;
1648   do
1649     {
1650       if (addr >= arange->low && addr < arange->high)
1651         return 1;
1652       arange = arange->next;
1653     }
1654   while (arange);
1655
1656   return 0;
1657 }
1658
1659 /* If UNIT contains ADDR, set the output parameters to the values for
1660    the line containing ADDR.  The output parameters, FILENAME_PTR,
1661    FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1662    to be filled in.
1663
1664    Return true of UNIT contains ADDR, and no errors were encountered;
1665    false otherwise.  */
1666
1667 static boolean
1668 comp_unit_find_nearest_line (unit, addr,
1669                              filename_ptr, functionname_ptr, linenumber_ptr,
1670                              stash)
1671      struct comp_unit* unit;
1672      bfd_vma addr;
1673      const char **filename_ptr;
1674      const char **functionname_ptr;
1675      unsigned int *linenumber_ptr;
1676      struct dwarf2_debug *stash;
1677 {
1678   boolean line_p;
1679   boolean func_p;
1680   struct funcinfo *function;
1681
1682   if (unit->error)
1683     return false;
1684
1685   if (! unit->line_table)
1686     {
1687       if (! unit->stmtlist)
1688         {
1689           unit->error = 1;
1690           return false;
1691         }
1692
1693       unit->line_table = decode_line_info (unit, stash);
1694
1695       if (! unit->line_table)
1696         {
1697           unit->error = 1;
1698           return false;
1699         }
1700
1701       if (unit->first_child_die_ptr < unit->end_ptr
1702           && ! scan_unit_for_functions (unit))
1703         {
1704           unit->error = 1;
1705           return false;
1706         }
1707     }
1708
1709   function = NULL;
1710   func_p = lookup_address_in_function_table (unit->function_table,
1711                                              addr,
1712                                              &function,
1713                                              functionname_ptr);
1714   line_p = lookup_address_in_line_info_table (unit->line_table,
1715                                               addr,
1716                                               function,
1717                                               filename_ptr,
1718                                               linenumber_ptr);
1719   return line_p || func_p;
1720 }
1721
1722 /* Locate a section in a BFD containing debugging info.  The search starts from the
1723    section after AFTER_SEC, or from the first section in the BFD if AFTER_SEC is
1724    NULL.  The search works by examining the names of the sections.  There are two
1725    permissiable names.  The first is .debug_info.  This is the standard DWARF2 name.
1726    The second is a prefix .gnu.linkonce.wi.  This is a variation on the .debug_info
1727    section which has a checksum describing the contents appended onto the name.  This
1728    allows the linker to identify and discard duplicate debugging sections for
1729    different 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,
1769                                addr_size, pinfo)
1770      bfd *abfd;
1771      asection *section;
1772      asymbol **symbols;
1773      bfd_vma offset;
1774      const char **filename_ptr;
1775      const char **functionname_ptr;
1776      unsigned int *linenumber_ptr;
1777      unsigned int addr_size;
1778      PTR *pinfo;
1779 {
1780   /* Read each compilation unit from the section .debug_info, and check
1781      to see if it contains the address we are searching for.  If yes,
1782      lookup the address, and return the line number info.  If no, go
1783      on to the next compilation unit.
1784
1785      We keep a list of all the previously read compilation units, and
1786      a pointer to the next un-read compilation unit.  Check the
1787      previously read units before reading more.  */
1788   struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
1789
1790   /* What address are we looking for?  */
1791   bfd_vma addr = offset + section->vma;
1792
1793   struct comp_unit* each;
1794
1795   *filename_ptr = NULL;
1796   *functionname_ptr = NULL;
1797   *linenumber_ptr = 0;
1798
1799   /* The DWARF2 spec says that the initial length field, and the
1800      offset of the abbreviation table, should both be 4-byte values.
1801      However, some compilers do things differently.  */
1802   if (addr_size == 0)
1803     addr_size = 4;
1804   BFD_ASSERT (addr_size == 4 || addr_size == 8);
1805
1806   if (! stash)
1807     {
1808       bfd_size_type total_size;
1809       asection *msec;
1810       bfd_size_type amt = sizeof (struct dwarf2_debug);
1811
1812       stash = (struct dwarf2_debug*) bfd_zalloc (abfd, amt);
1813       if (! stash)
1814         return false;
1815
1816       *pinfo = (PTR) stash;
1817
1818       msec = find_debug_info (abfd, NULL);
1819       if (! msec)
1820         /* No dwarf2 info.  Note that at this point the stash
1821            has been allocated, but contains zeros, this lets
1822            future calls to this function fail quicker.  */
1823          return false;
1824
1825       /* There can be more than one DWARF2 info section in a BFD these days.
1826          Read them all in and produce one large stash.  We do this in two
1827          passes - in the first pass we just accumulate the section sizes.
1828          In the second pass we read in the section's contents.  The allows
1829          us to avoid reallocing the data as we add sections to the stash.  */
1830       for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
1831         total_size += msec->_raw_size;
1832
1833       stash->info_ptr = (char *) bfd_alloc (abfd, total_size);
1834       if (stash->info_ptr == NULL)
1835         return false;
1836
1837       stash->info_ptr_end = stash->info_ptr;
1838
1839       for (msec = find_debug_info (abfd, NULL);
1840            msec;
1841            msec = find_debug_info (abfd, msec))
1842         {
1843           bfd_size_type size;
1844           bfd_size_type start;
1845
1846           size = msec->_raw_size;
1847           if (size == 0)
1848             continue;
1849
1850           start = stash->info_ptr_end - stash->info_ptr;
1851
1852           if (! bfd_get_section_contents (abfd, msec, stash->info_ptr + start,
1853                                           (bfd_vma) 0, size))
1854             continue;
1855
1856           stash->info_ptr_end = stash->info_ptr + start + size;
1857         }
1858
1859       BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
1860
1861       stash->sec = find_debug_info (abfd, NULL);
1862       stash->sec_info_ptr = stash->info_ptr;
1863       stash->syms = symbols;
1864     }
1865
1866   /* FIXME: There is a problem with the contents of the
1867      .debug_info section.  The 'low' and 'high' addresses of the
1868      comp_units are computed by relocs against symbols in the
1869      .text segment.  We need these addresses in order to determine
1870      the nearest line number, and so we have to resolve the
1871      relocs.  There is a similar problem when the .debug_line
1872      section is processed as well (e.g., there may be relocs
1873      against the operand of the DW_LNE_set_address operator).
1874
1875      Unfortunately getting hold of the reloc information is hard...
1876
1877      For now, this means that disassembling object files (as
1878      opposed to fully executables) does not always work as well as
1879      we would like.  */
1880
1881   /* A null info_ptr indicates that there is no dwarf2 info
1882      (or that an error occured while setting up the stash).  */
1883   if (! stash->info_ptr)
1884     return false;
1885
1886   /* Check the previously read comp. units first.  */
1887   for (each = stash->all_comp_units; each; each = each->next_unit)
1888     if (comp_unit_contains_address (each, addr))
1889       return comp_unit_find_nearest_line (each, addr, filename_ptr,
1890                                           functionname_ptr, linenumber_ptr,
1891                                           stash);
1892
1893   /* Read each remaining comp. units checking each as they are read.  */
1894   while (stash->info_ptr < stash->info_ptr_end)
1895     {
1896       bfd_vma length;
1897       boolean found;
1898       unsigned int offset_size = addr_size;
1899
1900       if (addr_size == 4)
1901         {
1902           length = read_4_bytes (abfd, stash->info_ptr);
1903           if (length == 0xffffffff)
1904             {
1905               offset_size = 8;
1906               length = read_8_bytes (abfd, stash->info_ptr + 4);
1907               stash->info_ptr += 8;
1908             }
1909         }
1910       else
1911         length = read_8_bytes (abfd, stash->info_ptr);
1912       stash->info_ptr += addr_size;
1913
1914       if (length > 0)
1915         {
1916           each = parse_comp_unit (abfd, stash, length, offset_size);
1917           stash->info_ptr += length;
1918
1919           if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
1920               == stash->sec->_raw_size)
1921             {
1922               stash->sec = find_debug_info (abfd, stash->sec);
1923               stash->sec_info_ptr = stash->info_ptr;
1924             }
1925
1926           if (each)
1927             {
1928               each->next_unit = stash->all_comp_units;
1929               stash->all_comp_units = each;
1930
1931               /* DW_AT_low_pc and DW_AT_high_pc are optional for
1932                  compilation units.  If we don't have them (i.e.,
1933                  unit->high == 0), we need to consult the line info
1934                  table to see if a compilation unit contains the given
1935                  address.  */
1936               if (each->arange.high > 0)
1937                 {
1938                   if (comp_unit_contains_address (each, addr))
1939                     return comp_unit_find_nearest_line (each, addr,
1940                                                        filename_ptr,
1941                                                        functionname_ptr,
1942                                                        linenumber_ptr,
1943                                                        stash);
1944                 }
1945               else
1946                 {
1947                   found = comp_unit_find_nearest_line (each, addr,
1948                                                        filename_ptr,
1949                                                        functionname_ptr,
1950                                                        linenumber_ptr,
1951                                                        stash);
1952                   if (found)
1953                     return true;
1954                 }
1955             }
1956         }
1957     }
1958
1959   return false;
1960 }