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