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