bfd/dwarf2.c

   1 /* DWARF 2 support.
   2    Copyright 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
   3
   4    Adapted from gdb/dwarf2read.c by Gavin Koch of Cygnus Solutions
   5    (gavin@cygnus.com).
   6
   7    From the dwarf2read.c header:
   8    Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
   9    Inc.  with support from Florida State University (under contract
  10    with the Ada Joint Program Office), and Silicon Graphics, Inc.
  11    Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
  12    based on Fred Fish's (Cygnus Support) implementation of DWARF 1
  13    support in dwarfread.c
  14
  15 This file is part of BFD.
  16
  17 This program is free software; you can redistribute it and/or modify
  18 it under the terms of the GNU General Public License as published by
  19 the Free Software Foundation; either version 2 of the License, or (at
  20 your option) any later version.
  21
  22 This program is distributed in the hope that it will be useful, but
  23 WITHOUT ANY WARRANTY; without even the implied warranty of
  24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  25 General Public License for more details.
  26
  27 You should have received a copy of the GNU General Public License
  28 along with this program; if not, write to the Free Software
  29 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  30
  31 #include "bfd.h"
  32 #include "sysdep.h"
  33 #include "libiberty.h"
  34 #include "libbfd.h"
  35 #include "elf-bfd.h"
  36 #include "elf/dwarf2.h"
  37
  38 /* The data in the .debug_line statement prologue looks like this.  */
  39 struct line_head
  40   {
  41     unsigned int total_length;
  42     unsigned short version;
  43     unsigned int prologue_length;
  44     unsigned char minimum_instruction_length;
  45     unsigned char default_is_stmt;
  46     int line_base;
  47     unsigned char line_range;
  48     unsigned char opcode_base;
  49     unsigned char *standard_opcode_lengths;
  50   };
  51
  52 /* Attributes have a name and a value */
  53 struct attribute
  54   {
  55     enum dwarf_attribute name;
  56     enum dwarf_form form;
  57     union
  58       {
  59         char *str;
  60         struct dwarf_block *blk;
  61         unsigned int unsnd;
  62         int snd;
  63         bfd_vma addr;
  64       }
  65     u;
  66   };
  67
  68 /* Get at parts of an attribute structure */
  69
  70 #define DW_STRING(attr)    ((attr)->u.str)
  71 #define DW_UNSND(attr)     ((attr)->u.unsnd)
  72 #define DW_BLOCK(attr)     ((attr)->u.blk)
  73 #define DW_SND(attr)       ((attr)->u.snd)
  74 #define DW_ADDR(attr)      ((attr)->u.addr)
  75
  76 /* Blocks are a bunch of untyped bytes. */
  77 struct dwarf_block
  78   {
  79     unsigned int size;
  80     char *data;
  81   };
  82
  83
  84 struct dwarf2_debug {
  85
  86   /* A list of all previously read comp_units. */
  87   struct comp_unit* all_comp_units;
  88
  89   /* The next unread compilation unit within the .debug_info section.
  90      Zero indicates that the .debug_info section has not been loaded
  91      into a buffer yet.*/
  92   char* info_ptr;
  93
  94   /* Pointer to the end of the .debug_info section memory buffer. */
  95   char* info_ptr_end;
  96
  97   /* Pointer to the .debug_abbrev section loaded into memory. */
  98   char* dwarf_abbrev_buffer;
  99
 100   /* Length of the loaded .debug_abbrev section. */
 101   unsigned long dwarf_abbrev_size;
 102 };
 103
 104
 105
 106 /* A minimal decoding of DWARF2 compilation units.  We only decode
 107    what's needed to get to the line number information. */
 108
 109 struct comp_unit {
 110
 111   /* Chain the previously read compilation units. */
 112   struct comp_unit* next_unit;
 113
 114   /* Keep the bdf convenient (for memory allocation). */
 115   bfd* abfd;
 116
 117   /* The lowest and higest addresses contained in this compilation
 118      unit as specified in the compilation unit header. */
 119   bfd_vma low;
 120   bfd_vma high;
 121
 122   /* The DW_AT_name attribute (for error messages). */
 123   char* name;
 124
 125   /* The abbrev hash table. */
 126   struct abbrev_info** abbrevs;
 127
 128   /* Note that an error was found by comp_unit_find_nearest_line. */
 129   int error;
 130
 131   /* The DW_AT_comp_dir attribute */
 132   char* comp_dir;
 133
 134   /* True if there is a line number table associated with this comp. unit. */
 135   int stmtlist;
 136
 137   /* The offset into .debug_line of the line number table. */
 138   unsigned long line_offset;
 139
 140   /* Pointer to the first child die for the comp unit. */
 141   char *first_child_die_ptr;
 142
 143   /* The end of the comp unit. */
 144   char *end_ptr;
 145
 146   /* The decoded line number, NULL if not yet decoded. */
 147   struct line_info_table* line_table;
 148
 149   /* A list of the functions found in this comp. unit. */
 150   struct funcinfo* function_table;
 151
 152   /* Address size for this unit - from unit header */
 153   unsigned char addr_size;
 154 };
 155
 156
 157
 158 /* VERBATIM
 159    The following function up to the END VERBATIM mark are
 160    copied directly from dwarf2read.c. */
 161
 162 /* read dwarf information from a buffer */
 163
 164 static unsigned int
 165 read_1_byte (abfd, buf)
 166      bfd *abfd;
 167      char *buf;
 168 {
 169   return bfd_get_8 (abfd, (bfd_byte *) buf);
 170 }
 171
 172 static int
 173 read_1_signed_byte (abfd, buf)
 174      bfd *abfd;
 175      char *buf;
 176 {
 177   return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
 178 }
 179
 180 static unsigned int
 181 read_2_bytes (abfd, buf)
 182      bfd *abfd;
 183      char *buf;
 184 {
 185   return bfd_get_16 (abfd, (bfd_byte *) buf);
 186 }
 187
 188 #if 0
 189
 190 /* This is not used.  */
 191
 192 static int
 193 read_2_signed_bytes (abfd, buf)
 194      bfd *abfd;
 195      char *buf;
 196 {
 197   return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
 198 }
 199
 200 #endif
 201
 202 static unsigned int
 203 read_4_bytes (abfd, buf)
 204      bfd *abfd;
 205      char *buf;
 206 {
 207   return bfd_get_32 (abfd, (bfd_byte *) buf);
 208 }
 209
 210 #if 0
 211
 212 /* This is not used.  */
 213
 214 static int
 215 read_4_signed_bytes (abfd, buf)
 216      bfd *abfd;
 217      char *buf;
 218 {
 219   return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
 220 }
 221
 222 #endif
 223
 224 static unsigned int
 225 read_8_bytes (abfd, buf)
 226      bfd *abfd;
 227      char *buf;
 228 {
 229   return bfd_get_64 (abfd, (bfd_byte *) buf);
 230 }
 231
 232 static char *
 233 read_n_bytes (abfd, buf, size)
 234      bfd * abfd;
 235      char *buf;
 236      unsigned int size;
 237 {
 238   /* If the size of a host char is 8 bits, we can return a pointer
 239      to the buffer, otherwise we have to copy the data to a buffer
 240      allocated on the temporary obstack.  */
 241   return buf;
 242 }
 243
 244 static char *
 245 read_string (abfd, buf, bytes_read_ptr)
 246      bfd *abfd;
 247      char *buf;
 248      unsigned int *bytes_read_ptr;
 249 {
 250   /* If the size of a host char is 8 bits, we can return a pointer
 251      to the string, otherwise we have to copy the string to a buffer
 252      allocated on the temporary obstack.  */
 253   if (*buf == '\0')
 254     {
 255       *bytes_read_ptr = 1;
 256       return NULL;
 257     }
 258   *bytes_read_ptr = strlen (buf) + 1;
 259   return buf;
 260 }
 261
 262 static unsigned int
 263 read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
 264      bfd *abfd;
 265      char *buf;
 266      unsigned int *bytes_read_ptr;
 267 {
 268   unsigned int  result;
 269   unsigned int  num_read;
 270   int           shift;
 271   unsigned char byte;
 272
 273   result   = 0;
 274   shift    = 0;
 275   num_read = 0;
 276
 277   do
 278     {
 279       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
 280       buf ++;
 281       num_read ++;
 282       result |= ((byte & 0x7f) << shift);
 283       shift += 7;
 284     }
 285   while (byte & 0x80);
 286
 287   * bytes_read_ptr = num_read;
 288
 289   return result;
 290 }
 291
 292 static int
 293 read_signed_leb128 (abfd, buf, bytes_read_ptr)
 294      bfd * abfd;
 295      char * buf;
 296      unsigned int * bytes_read_ptr;
 297 {
 298   int           result;
 299   int           shift;
 300   int           num_read;
 301   unsigned char byte;
 302
 303   result = 0;
 304   shift = 0;
 305   num_read = 0;
 306
 307   do
 308     {
 309       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
 310       buf ++;
 311       num_read ++;
 312       result |= ((byte & 0x7f) << shift);
 313       shift += 7;
 314     }
 315   while (byte & 0x80);
 316
 317   if ((shift < 32) && (byte & 0x40))
 318     result |= -(1 << shift);
 319
 320   * bytes_read_ptr = num_read;
 321
 322   return result;
 323 }
 324
 325 /* END VERBATIM */
 326
 327 static bfd_vma
 328 read_address (unit, buf)
 329      struct comp_unit* unit;
 330      char *buf;
 331 {
 332   bfd_vma retval = 0;
 333
 334   if (unit->addr_size == 4)
 335     {
 336       retval = bfd_get_32 (unit->abfd, (bfd_byte *) buf);
 337     } else {
 338       retval = bfd_get_64 (unit->abfd, (bfd_byte *) buf);
 339     }
 340   return retval;
 341 }
 342
 343
 344
 345
 346
 347 /* This data structure holds the information of an abbrev. */
 348 struct abbrev_info
 349   {
 350     unsigned int number;        /* number identifying abbrev */
 351     enum dwarf_tag tag;         /* dwarf tag */
 352     int has_children;           /* boolean */
 353     unsigned int num_attrs;     /* number of attributes */
 354     struct attr_abbrev *attrs;  /* an array of attribute descriptions */
 355     struct abbrev_info *next;   /* next in chain */
 356   };
 357
 358 struct attr_abbrev
 359   {
 360     enum dwarf_attribute name;
 361     enum dwarf_form form;
 362   };
 363
 364 #ifndef ABBREV_HASH_SIZE
 365 #define ABBREV_HASH_SIZE 121
 366 #endif
 367 #ifndef ATTR_ALLOC_CHUNK
 368 #define ATTR_ALLOC_CHUNK 4
 369 #endif
 370
 371 /* Lookup an abbrev_info structure in the abbrev hash table.  */
 372
 373 static struct abbrev_info *
 374 lookup_abbrev (number,abbrevs)
 375      unsigned int number;
 376      struct abbrev_info **abbrevs;
 377 {
 378   unsigned int hash_number;
 379   struct abbrev_info *abbrev;
 380
 381   hash_number = number % ABBREV_HASH_SIZE;
 382   abbrev = abbrevs[hash_number];
 383
 384   while (abbrev)
 385     {
 386       if (abbrev->number == number)
 387         return abbrev;
 388       else
 389         abbrev = abbrev->next;
 390     }
 391   return NULL;
 392 }
 393
 394 /* In DWARF version 2, the description of the debugging information is
 395    stored in a separate .debug_abbrev section.  Before we read any
 396    dies from a section we read in all abbreviations and install them
 397    in a hash table.  */
 398
 399 static struct abbrev_info**
 400 read_abbrevs (abfd, offset)
 401      bfd * abfd;
 402      unsigned int offset;
 403 {
 404   struct abbrev_info **abbrevs;
 405   char *abbrev_ptr;
 406   struct abbrev_info *cur_abbrev;
 407   unsigned int abbrev_number, bytes_read, abbrev_name;
 408   unsigned int abbrev_form, hash_number;
 409   struct dwarf2_debug *stash;
 410
 411   stash = elf_tdata(abfd)->dwarf2_find_line_info;
 412
 413   if (! stash->dwarf_abbrev_buffer)
 414     {
 415       asection *msec;
 416
 417       msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
 418       if (! msec)
 419         {
 420           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
 421           bfd_set_error (bfd_error_bad_value);
 422           return 0;
 423         }
 424
 425       stash->dwarf_abbrev_size = bfd_get_section_size_before_reloc (msec);
 426       stash->dwarf_abbrev_buffer = (char*) bfd_alloc (abfd, stash->dwarf_abbrev_size);
 427       if (! stash->dwarf_abbrev_buffer)
 428           return 0;
 429
 430       if (! bfd_get_section_contents (abfd, msec,
 431                                       stash->dwarf_abbrev_buffer, 0,
 432                                       stash->dwarf_abbrev_size))
 433         return 0;
 434     }
 435
 436   if (offset > stash->dwarf_abbrev_size)
 437     {
 438       (*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%u) bigger than abbrev size (%u)."),
 439                              offset, stash->dwarf_abbrev_size );
 440       bfd_set_error (bfd_error_bad_value);
 441       return 0;
 442     }
 443
 444   abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, sizeof(struct abbrev_info*) * ABBREV_HASH_SIZE);
 445
 446   abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
 447   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 448   abbrev_ptr += bytes_read;
 449
 450   /* loop until we reach an abbrev number of 0 */
 451   while (abbrev_number)
 452     {
 453       cur_abbrev = (struct abbrev_info*)bfd_zalloc (abfd, sizeof (struct abbrev_info));
 454
 455       /* read in abbrev header */
 456       cur_abbrev->number = abbrev_number;
 457       cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 458       abbrev_ptr += bytes_read;
 459       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
 460       abbrev_ptr += 1;
 461
 462       /* now read in declarations */
 463       abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 464       abbrev_ptr += bytes_read;
 465       abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 466       abbrev_ptr += bytes_read;
 467       while (abbrev_name)
 468         {
 469           if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
 470             {
 471               cur_abbrev->attrs = (struct attr_abbrev *)
 472                 bfd_realloc (cur_abbrev->attrs,
 473                              (cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK)
 474                              * sizeof (struct attr_abbrev));
 475               if (! cur_abbrev->attrs)
 476                 return 0;
 477             }
 478           cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
 479           cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
 480           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 481           abbrev_ptr += bytes_read;
 482           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 483           abbrev_ptr += bytes_read;
 484         }
 485
 486       hash_number = abbrev_number % ABBREV_HASH_SIZE;
 487       cur_abbrev->next = abbrevs[hash_number];
 488       abbrevs[hash_number] = cur_abbrev;
 489
 490       /* Get next abbreviation.
 491          Under Irix6 the abbreviations for a compilation unit are not
 492          always properly terminated with an abbrev number of 0.
 493          Exit loop if we encounter an abbreviation which we have
 494          already read (which means we are about to read the abbreviations
 495          for the next compile unit) or if the end of the abbreviation
 496          table is reached.  */
 497       if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
 498             >= stash->dwarf_abbrev_size)
 499         break;
 500       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 501       abbrev_ptr += bytes_read;
 502       if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
 503         break;
 504     }
 505
 506   return abbrevs;
 507 }
 508
 509 /* Read an attribute described by an abbreviated attribute.  */
 510
 511 static char *
 512 read_attribute (attr, abbrev, unit, info_ptr)
 513      struct attribute   *attr;
 514      struct attr_abbrev *abbrev;
 515      struct comp_unit   *unit;
 516      char               *info_ptr;
 517 {
 518   bfd *abfd = unit->abfd;
 519   unsigned int bytes_read;
 520   struct dwarf_block *blk;
 521
 522   attr->name = abbrev->name;
 523   attr->form = abbrev->form;
 524   switch (abbrev->form)
 525     {
 526     case DW_FORM_addr:
 527     case DW_FORM_ref_addr:
 528       DW_ADDR (attr) = read_address (unit, info_ptr);
 529       info_ptr += unit->addr_size;
 530       break;
 531     case DW_FORM_block2:
 532       blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
 533       blk->size = read_2_bytes (abfd, info_ptr);
 534       info_ptr += 2;
 535       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 536       info_ptr += blk->size;
 537       DW_BLOCK (attr) = blk;
 538       break;
 539     case DW_FORM_block4:
 540       blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
 541       blk->size = read_4_bytes (abfd, info_ptr);
 542       info_ptr += 4;
 543       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 544       info_ptr += blk->size;
 545       DW_BLOCK (attr) = blk;
 546       break;
 547     case DW_FORM_data2:
 548       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
 549       info_ptr += 2;
 550       break;
 551     case DW_FORM_data4:
 552       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
 553       info_ptr += 4;
 554       break;
 555     case DW_FORM_data8:
 556       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
 557       info_ptr += 8;
 558       break;
 559     case DW_FORM_string:
 560       DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
 561       info_ptr += bytes_read;
 562       break;
 563     case DW_FORM_block:
 564       blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
 565       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 566       info_ptr += bytes_read;
 567       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 568       info_ptr += blk->size;
 569       DW_BLOCK (attr) = blk;
 570       break;
 571     case DW_FORM_block1:
 572       blk = (struct dwarf_block *) bfd_alloc (abfd, sizeof (struct dwarf_block));
 573       blk->size = read_1_byte (abfd, info_ptr);
 574       info_ptr += 1;
 575       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
 576       info_ptr += blk->size;
 577       DW_BLOCK (attr) = blk;
 578       break;
 579     case DW_FORM_data1:
 580       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
 581       info_ptr += 1;
 582       break;
 583     case DW_FORM_flag:
 584       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
 585       info_ptr += 1;
 586       break;
 587     case DW_FORM_sdata:
 588       DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
 589       info_ptr += bytes_read;
 590       break;
 591     case DW_FORM_udata:
 592       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 593       info_ptr += bytes_read;
 594       break;
 595     case DW_FORM_ref1:
 596       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
 597       info_ptr += 1;
 598       break;
 599     case DW_FORM_ref2:
 600       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
 601       info_ptr += 2;
 602       break;
 603     case DW_FORM_ref4:
 604       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
 605       info_ptr += 4;
 606       break;
 607     case DW_FORM_ref_udata:
 608       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
 609       info_ptr += bytes_read;
 610       break;
 611     case DW_FORM_strp:
 612     case DW_FORM_indirect:
 613     default:
 614       (*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %d."),
 615                              abbrev->form);
 616       bfd_set_error (bfd_error_bad_value);
 617     }
 618   return info_ptr;
 619 }
 620
 621
 622 /* Source line information table routines. */
 623
 624 #define FILE_ALLOC_CHUNK 5
 625 #define DIR_ALLOC_CHUNK 5
 626
 627 struct line_info {
 628   struct line_info* prev_line;
 629
 630   bfd_vma address;
 631   char* filename;
 632   unsigned int line;
 633   unsigned int column;
 634   int end_sequence;             /* end of (sequential) code sequence */
 635 };
 636
 637 struct fileinfo {
 638   char *name;
 639   unsigned int dir;
 640   unsigned int time;
 641   unsigned int size;
 642 };
 643
 644 struct line_info_table {
 645   bfd* abfd;
 646
 647   unsigned int num_files;
 648   unsigned int num_dirs;
 649
 650   char* comp_dir;
 651   char** dirs;
 652   struct fileinfo* files;
 653   struct line_info* last_line;
 654 };
 655
 656 static void
 657 add_line_info (table, address, filename, line, column, end_sequence)
 658      struct line_info_table* table;
 659      bfd_vma address;
 660      char* filename;
 661      unsigned int line;
 662      unsigned int column;
 663      int end_sequence;
 664 {
 665   struct line_info* info = (struct line_info*)
 666     bfd_alloc (table->abfd, sizeof (struct line_info));
 667
 668   info->prev_line = table->last_line;
 669   table->last_line = info;
 670
 671   info->address = address;
 672   info->filename = filename;
 673   info->line = line;
 674   info->column = column;
 675   info->end_sequence = end_sequence;
 676 }
 677
 678 static char*
 679 concat_filename (table, file)
 680      struct line_info_table* table;
 681      unsigned int file;
 682 {
 683   char* filename;
 684
 685   if (file - 1 >= table->num_files)
 686     {
 687       (*_bfd_error_handler) (_("Dwarf Error: mangled line number "
 688                                "section (bad file number)."));
 689       return "<unknown>";
 690     }
 691
 692   filename = table->files[file - 1].name;
 693   if (*filename == '/')
 694     return filename;
 695
 696   else
 697     {
 698       char* dirname = (table->files[file - 1].dir
 699                        ? table->dirs[table->files[file - 1].dir - 1]
 700                        : table->comp_dir);
 701       return (char*) concat (dirname, "/", filename, NULL);
 702     }
 703 }
 704
 705 /* Decode the line number information for UNIT. */
 706
 707 static struct line_info_table*
 708 decode_line_info (unit)
 709      struct comp_unit *unit;
 710 {
 711   bfd *abfd = unit->abfd;
 712
 713   static char* dwarf_line_buffer = 0;
 714
 715   struct line_info_table* table;
 716
 717   char *line_ptr;
 718   char *line_end;
 719   struct line_head lh;
 720   unsigned int i, bytes_read;
 721   char *cur_file, *cur_dir;
 722   unsigned char op_code, extended_op, adj_opcode;
 723 #if 0
 724   /* This optimization unfortunately does not work well on programs
 725      that have multiple sections containing text (such as Linux which
 726      uses .text, and .text.init, for example.  */
 727   bfd_vma hi_pc = 0, lo_pc = ~ (bfd_vma) 0;
 728 #endif
 729
 730   if (! dwarf_line_buffer)
 731     {
 732       asection *msec;
 733       unsigned long size;
 734
 735       msec = bfd_get_section_by_name (abfd, ".debug_line");
 736       if (! msec)
 737         {
 738           (*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
 739           bfd_set_error (bfd_error_bad_value);
 740           return 0;
 741         }
 742
 743       size = bfd_get_section_size_before_reloc (msec);
 744       dwarf_line_buffer = (char*) bfd_alloc (abfd, size);
 745       if (! dwarf_line_buffer)
 746         return 0;
 747
 748       if (! bfd_get_section_contents (abfd, msec,
 749                                       dwarf_line_buffer, 0,
 750                                       size))
 751         return 0;
 752
 753       /* FIXME: We ought to apply the relocs against this section before
 754          we process it.... */
 755     }
 756
 757   table = (struct line_info_table*) bfd_alloc (abfd,
 758                                                sizeof (struct line_info_table));
 759   table->abfd = abfd;
 760   table->comp_dir = unit->comp_dir;
 761
 762   table->num_files = 0;
 763   table->files = NULL;
 764
 765   table->num_dirs = 0;
 766   table->dirs = NULL;
 767
 768   table->files = NULL;
 769   table->last_line = NULL;
 770
 771   line_ptr = dwarf_line_buffer + unit->line_offset;
 772
 773   /* read in the prologue */
 774   lh.total_length = read_4_bytes (abfd, line_ptr);
 775   line_ptr += 4;
 776   line_end = line_ptr + lh.total_length;
 777   lh.version = read_2_bytes (abfd, line_ptr);
 778   line_ptr += 2;
 779   lh.prologue_length = read_4_bytes (abfd, line_ptr);
 780   line_ptr += 4;
 781   lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
 782   line_ptr += 1;
 783   lh.default_is_stmt = read_1_byte (abfd, line_ptr);
 784   line_ptr += 1;
 785   lh.line_base = read_1_signed_byte (abfd, line_ptr);
 786   line_ptr += 1;
 787   lh.line_range = read_1_byte (abfd, line_ptr);
 788   line_ptr += 1;
 789   lh.opcode_base = read_1_byte (abfd, line_ptr);
 790   line_ptr += 1;
 791   lh.standard_opcode_lengths = (unsigned char *)
 792     bfd_alloc (abfd, lh.opcode_base * sizeof (unsigned char));
 793
 794   lh.standard_opcode_lengths[0] = 1;
 795   for (i = 1; i < lh.opcode_base; ++i)
 796     {
 797       lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
 798       line_ptr += 1;
 799     }
 800
 801   /* Read directory table  */
 802   while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
 803     {
 804       line_ptr += bytes_read;
 805       if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
 806         {
 807           table->dirs = (char **)
 808             bfd_realloc (table->dirs,
 809                          (table->num_dirs + DIR_ALLOC_CHUNK) * sizeof (char *));
 810           if (! table->dirs)
 811             return 0;
 812         }
 813       table->dirs[table->num_dirs++] = cur_dir;
 814     }
 815   line_ptr += bytes_read;
 816
 817   /* Read file name table */
 818   while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
 819     {
 820       line_ptr += bytes_read;
 821       if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
 822         {
 823           table->files = (struct fileinfo *)
 824             bfd_realloc (table->files,
 825                          (table->num_files + FILE_ALLOC_CHUNK)
 826                          * sizeof (struct fileinfo));
 827           if (! table->files)
 828             return 0;
 829         }
 830       table->files[table->num_files].name = cur_file;
 831       table->files[table->num_files].dir =
 832         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 833       line_ptr += bytes_read;
 834       table->files[table->num_files].time =
 835         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 836       line_ptr += bytes_read;
 837       table->files[table->num_files].size =
 838         read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 839       line_ptr += bytes_read;
 840       table->num_files++;
 841     }
 842   line_ptr += bytes_read;
 843
 844   /* Read the statement sequences until there's nothing left.  */
 845   while (line_ptr < line_end)
 846     {
 847       /* state machine registers  */
 848       bfd_vma address = 0;
 849       char* filename = concat_filename (table, 1);
 850       unsigned int line = 1;
 851       unsigned int column = 0;
 852       int is_stmt = lh.default_is_stmt;
 853       int basic_block = 0;
 854       int end_sequence = 0;
 855
 856       /* Decode the table. */
 857       while (! end_sequence)
 858         {
 859           op_code = read_1_byte (abfd, line_ptr);
 860           line_ptr += 1;
 861           switch (op_code)
 862             {
 863             case DW_LNS_extended_op:
 864               line_ptr += 1;    /* ignore length */
 865               extended_op = read_1_byte (abfd, line_ptr);
 866               line_ptr += 1;
 867               switch (extended_op)
 868                 {
 869                 case DW_LNE_end_sequence:
 870                   end_sequence = 1;
 871                   add_line_info (table, address, filename, line, column, end_sequence);
 872                   break;
 873                 case DW_LNE_set_address:
 874                   address = read_address (unit, line_ptr);
 875                   line_ptr += unit->addr_size;
 876                   break;
 877                 case DW_LNE_define_file:
 878                   cur_file = read_string (abfd, line_ptr, &bytes_read);
 879                   line_ptr += bytes_read;
 880                   if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
 881                     {
 882                       table->files = (struct fileinfo *)
 883                         bfd_realloc (table->files,
 884                                      (table->num_files + FILE_ALLOC_CHUNK)
 885                                      * sizeof (struct fileinfo));
 886                       if (! table->files)
 887                         return 0;
 888                     }
 889                   table->files[table->num_files].name = cur_file;
 890                   table->files[table->num_files].dir =
 891                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 892                   line_ptr += bytes_read;
 893                   table->files[table->num_files].time =
 894                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 895                   line_ptr += bytes_read;
 896                   table->files[table->num_files].size =
 897                     read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 898                   line_ptr += bytes_read;
 899                   table->num_files++;
 900                   break;
 901                 default:
 902                   (*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
 903                   bfd_set_error (bfd_error_bad_value);
 904                   return 0;
 905                 }
 906               break;
 907             case DW_LNS_copy:
 908               add_line_info (table, address, filename, line, column, 0);
 909               basic_block = 0;
 910               break;
 911             case DW_LNS_advance_pc:
 912               address += lh.minimum_instruction_length
 913                 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 914               line_ptr += bytes_read;
 915               break;
 916             case DW_LNS_advance_line:
 917               line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
 918               line_ptr += bytes_read;
 919               break;
 920             case DW_LNS_set_file:
 921               {
 922                 unsigned int file;
 923
 924                 /* The file and directory tables are 0 based, the references
 925                    are 1 based.  */
 926                 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 927                 line_ptr += bytes_read;
 928                 filename = concat_filename (table, file);
 929                 break;
 930               }
 931             case DW_LNS_set_column:
 932               column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
 933               line_ptr += bytes_read;
 934               break;
 935             case DW_LNS_negate_stmt:
 936               is_stmt = (!is_stmt);
 937               break;
 938             case DW_LNS_set_basic_block:
 939               basic_block = 1;
 940               break;
 941             case DW_LNS_const_add_pc:
 942               address += lh.minimum_instruction_length
 943                       * ((255 - lh.opcode_base) / lh.line_range);
 944               break;
 945             case DW_LNS_fixed_advance_pc:
 946               address += read_2_bytes (abfd, line_ptr);
 947               line_ptr += 2;
 948               break;
 949             default:            /* special operand */
 950               adj_opcode = op_code - lh.opcode_base;
 951               address += (adj_opcode / lh.line_range)
 952                 * lh.minimum_instruction_length;
 953               line += lh.line_base + (adj_opcode % lh.line_range);
 954               /* append row to matrix using current values */
 955               add_line_info (table, address, filename, line, column, 0);
 956               basic_block = 1;
 957             }
 958 #if 0
 959           if (unit->high == 0)
 960             {
 961               if (address > hi_pc)
 962                 hi_pc = address;
 963               if (address < lo_pc)
 964                 lo_pc = address;
 965             }
 966 #endif
 967         }
 968     }
 969 #if 0
 970   if (unit->high == 0 && hi_pc != 0)
 971     {
 972       unit->high = hi_pc;
 973       unit->low = lo_pc;
 974     }
 975 #endif
 976
 977   return table;
 978 }
 979
 980
 981 /* If ADDR is within TABLE set the output parameters and return true,
 982    otherwise return false.  The output parameters, FILENAME_PTR and
 983    LINENUMBER_PTR, are pointers to the objects to be filled in. */
 984
 985 static boolean
 986 lookup_address_in_line_info_table (table,
 987                                    addr,
 988                                    filename_ptr,
 989                                    linenumber_ptr)
 990      struct line_info_table* table;
 991      bfd_vma addr;
 992      const char **filename_ptr;
 993      unsigned int *linenumber_ptr;
 994 {
 995   struct line_info* next_line = table->last_line;
 996   struct line_info* each_line;
 997
 998   if (!next_line)
 999     return false;
1000
1001   each_line = next_line->prev_line;
1002
1003   while (each_line && next_line)
1004     {
1005       if (!each_line->end_sequence
1006           && addr >= each_line->address && addr < next_line->address)
1007         {
1008           *filename_ptr = each_line->filename;
1009           *linenumber_ptr = each_line->line;
1010           return true;
1011         }
1012       next_line = each_line;
1013       each_line = each_line->prev_line;
1014     }
1015
1016   return false;
1017 }
1018
1019
1020
1021
1022 /* Function table functions. */
1023
1024 struct funcinfo {
1025   struct funcinfo *prev_func;
1026
1027   char* name;
1028   bfd_vma low;
1029   bfd_vma high;
1030 };
1031
1032
1033 /* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true. */
1034
1035 static boolean
1036 lookup_address_in_function_table (table,
1037                                   addr,
1038                                   functionname_ptr)
1039      struct funcinfo* table;
1040      bfd_vma addr;
1041      const char **functionname_ptr;
1042 {
1043   struct funcinfo* each_func;
1044
1045   for (each_func = table;
1046        each_func;
1047        each_func = each_func->prev_func)
1048     {
1049       if (addr >= each_func->low && addr < each_func->high)
1050         {
1051           *functionname_ptr = each_func->name;
1052           return true;
1053         }
1054     }
1055
1056   return false;
1057 }
1058
1059
1060
1061
1062 /* DWARF2 Compilation unit functions. */
1063
1064
1065 /* Scan over each die in a comp. unit looking for functions to add
1066    to the function table. */
1067
1068 static boolean
1069 scan_unit_for_functions (unit)
1070      struct comp_unit *unit;
1071 {
1072   bfd *abfd = unit->abfd;
1073   char *info_ptr = unit->first_child_die_ptr;
1074   int nesting_level = 1;
1075
1076   while (nesting_level)
1077     {
1078       unsigned int abbrev_number, bytes_read, i;
1079       struct abbrev_info *abbrev;
1080       struct attribute attr;
1081       struct funcinfo *func;
1082       char* name = 0;
1083
1084       abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1085       info_ptr += bytes_read;
1086
1087       if (! abbrev_number)
1088         {
1089           nesting_level--;
1090           continue;
1091         }
1092
1093       abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
1094       if (! abbrev)
1095         {
1096           (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
1097                              abbrev_number);
1098           bfd_set_error (bfd_error_bad_value);
1099           return false;
1100         }
1101
1102       if (abbrev->tag == DW_TAG_subprogram)
1103         {
1104           func = (struct funcinfo*) bfd_zalloc (abfd, sizeof (struct funcinfo));
1105           func->prev_func = unit->function_table;
1106           unit->function_table = func;
1107         }
1108       else
1109         func = NULL;
1110
1111       for (i = 0; i < abbrev->num_attrs; ++i)
1112         {
1113           info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1114
1115           if (func)
1116             {
1117               switch (attr.name)
1118                 {
1119                 case DW_AT_name:
1120
1121                   name = DW_STRING (&attr);
1122
1123                   /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name.  */
1124                   if (func->name == NULL)
1125                     func->name = DW_STRING (&attr);
1126                   break;
1127
1128                 case DW_AT_MIPS_linkage_name:
1129                   func->name = DW_STRING (&attr);
1130                   break;
1131
1132                 case DW_AT_low_pc:
1133                   func->low = DW_ADDR (&attr);
1134                   break;
1135
1136                 case DW_AT_high_pc:
1137                   func->high = DW_ADDR (&attr);
1138                   break;
1139
1140                 default:
1141                   break;
1142                 }
1143             }
1144           else
1145             {
1146               switch (attr.name)
1147                 {
1148                 case DW_AT_name:
1149                   name = DW_STRING (&attr);
1150                   break;
1151
1152                 default:
1153                   break;
1154                 }
1155             }
1156         }
1157
1158       if (abbrev->has_children)
1159         nesting_level++;
1160     }
1161
1162   return true;
1163 }
1164
1165
1166
1167
1168
1169
1170 /* Parse a DWARF2 compilation unit starting at INFO_PTR.  This includes
1171    the compilation unit header that proceeds the DIE's, but does not
1172    include the length field that preceeds each compilation unit header.
1173    END_PTR points one past the end of this comp unit.
1174
1175    This routine does not read the whole compilation unit; only enough
1176    to get to the line number information for the compilation unit.  */
1177
1178 static struct comp_unit *
1179 parse_comp_unit (abfd, info_ptr, end_ptr)
1180      bfd* abfd;
1181      char* info_ptr;
1182      char* end_ptr;
1183 {
1184   struct comp_unit* unit;
1185
1186   unsigned short version;
1187   unsigned int abbrev_offset;
1188   unsigned char addr_size;
1189   struct abbrev_info** abbrevs;
1190
1191   unsigned int abbrev_number, bytes_read, i;
1192   struct abbrev_info *abbrev;
1193   struct attribute attr;
1194
1195   version = read_2_bytes (abfd, info_ptr);
1196   info_ptr += 2;
1197   abbrev_offset = read_4_bytes (abfd, info_ptr);
1198   info_ptr += 4;
1199   addr_size = read_1_byte (abfd, info_ptr);
1200   info_ptr += 1;
1201
1202   if (version != 2)
1203     {
1204       (*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%hu', this reader only handles version 2 information."), version );
1205       bfd_set_error (bfd_error_bad_value);
1206       return 0;
1207     }
1208
1209   if (addr_size > sizeof (bfd_vma))
1210     {
1211       (*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
1212                          addr_size,
1213                          sizeof (bfd_vma));
1214       bfd_set_error (bfd_error_bad_value);
1215       return 0;
1216     }
1217
1218   if (addr_size != 4 && addr_size != 8)
1219     {
1220       (*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '4' and '8'.", addr_size );
1221       bfd_set_error (bfd_error_bad_value);
1222       return 0;
1223     }
1224
1225   /* Read the abbrevs for this compilation unit into a table */
1226   abbrevs = read_abbrevs (abfd, abbrev_offset);
1227   if (! abbrevs)
1228       return 0;
1229
1230   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
1231   info_ptr += bytes_read;
1232   if (! abbrev_number)
1233     {
1234       (*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %d."),
1235                          abbrev_number);
1236       bfd_set_error (bfd_error_bad_value);
1237       return 0;
1238     }
1239
1240   abbrev = lookup_abbrev (abbrev_number, abbrevs);
1241   if (! abbrev)
1242     {
1243       (*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
1244                          abbrev_number);
1245       bfd_set_error (bfd_error_bad_value);
1246       return 0;
1247     }
1248
1249   unit = (struct comp_unit*) bfd_zalloc (abfd, sizeof (struct comp_unit));
1250   unit->abfd = abfd;
1251   unit->addr_size = addr_size;
1252   unit->abbrevs = abbrevs;
1253   unit->end_ptr = end_ptr;
1254
1255   for (i = 0; i < abbrev->num_attrs; ++i)
1256     {
1257       info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
1258
1259       /* Store the data if it is of an attribute we want to keep in a
1260          partial symbol table.  */
1261       switch (attr.name)
1262         {
1263         case DW_AT_stmt_list:
1264           unit->stmtlist = 1;
1265           unit->line_offset = DW_UNSND (&attr);
1266           break;
1267
1268         case DW_AT_name:
1269           unit->name = DW_STRING (&attr);
1270           break;
1271
1272         case DW_AT_low_pc:
1273           unit->low = DW_ADDR (&attr);
1274           break;
1275
1276         case DW_AT_high_pc:
1277           unit->high = DW_ADDR (&attr);
1278           break;
1279
1280         case DW_AT_comp_dir:
1281           {
1282             char* comp_dir = DW_STRING (&attr);
1283             if (comp_dir)
1284               {
1285                 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1286                    directory, get rid of it.  */
1287                 char *cp = (char*) strchr (comp_dir, ':');
1288
1289                 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1290                   comp_dir = cp + 1;
1291               }
1292             unit->comp_dir = comp_dir;
1293             break;
1294           }
1295
1296         default:
1297           break;
1298         }
1299     }
1300
1301   unit->first_child_die_ptr = info_ptr;
1302   return unit;
1303 }
1304
1305
1306
1307
1308
1309 /* Return true if UNIT contains the address given by ADDR. */
1310
1311 static boolean
1312 comp_unit_contains_address (unit, addr)
1313      struct comp_unit* unit;
1314      bfd_vma addr;
1315 {
1316   return ! unit->error
1317     && (addr >= unit->low && addr <= unit->high);
1318 }
1319
1320
1321 /* If UNIT contains ADDR, set the output parameters to the values for
1322    the line containing ADDR.  The output parameters, FILENAME_PTR,
1323    FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
1324    to be filled in.
1325
1326    Return true of UNIT contains ADDR, and no errors were encountered;
1327    false otherwise.  */
1328
1329 static boolean
1330 comp_unit_find_nearest_line (unit, addr,
1331                              filename_ptr, functionname_ptr, linenumber_ptr)
1332      struct comp_unit* unit;
1333      bfd_vma addr;
1334      const char **filename_ptr;
1335      const char **functionname_ptr;
1336      unsigned int *linenumber_ptr;
1337 {
1338   boolean line_p;
1339   boolean func_p;
1340
1341   if (unit->error)
1342     return false;
1343
1344   if (! unit->line_table)
1345     {
1346       if (! unit->stmtlist)
1347         {
1348           unit->error = 1;
1349           return false;
1350         }
1351
1352       unit->line_table = decode_line_info (unit);
1353
1354       if (! unit->line_table)
1355         {
1356           unit->error = 1;
1357           return false;
1358         }
1359
1360       if (! scan_unit_for_functions (unit))
1361         {
1362           unit->error = 1;
1363           return false;
1364         }
1365     }
1366
1367   line_p = lookup_address_in_line_info_table (unit->line_table,
1368                                               addr,
1369                                               filename_ptr,
1370                                               linenumber_ptr);
1371   func_p = lookup_address_in_function_table (unit->function_table,
1372                                              addr,
1373                                              functionname_ptr);
1374   return line_p || func_p;
1375 }
1376
1377 /* The DWARF2 version of find_nearest line.
1378    Return true if the line is found without error. */
1379
1380 boolean
1381 _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
1382                           filename_ptr, functionname_ptr, linenumber_ptr)
1383      bfd *abfd;
1384      asection *section;
1385      asymbol **symbols;
1386      bfd_vma offset;
1387      const char **filename_ptr;
1388      const char **functionname_ptr;
1389      unsigned int *linenumber_ptr;
1390 {
1391   /* Read each compilation unit from the section .debug_info, and check
1392      to see if it contains the address we are searching for.  If yes,
1393      lookup the address, and return the line number info.  If no, go
1394      on to the next compilation unit.
1395
1396      We keep a list of all the previously read compilation units, and
1397      a pointer to the next un-read compilation unit.  Check the
1398      previously read units before reading more.
1399      */
1400
1401   struct dwarf2_debug *stash = elf_tdata (abfd)->dwarf2_find_line_info;
1402
1403   /* What address are we looking for? */
1404   bfd_vma addr = offset + section->vma;
1405
1406   struct comp_unit* each;
1407
1408   boolean found;
1409
1410   *filename_ptr = NULL;
1411   *functionname_ptr = NULL;
1412   *linenumber_ptr = 0;
1413
1414   if (! stash)
1415     {
1416       asection *msec;
1417       unsigned long size;
1418
1419       stash = elf_tdata (abfd)->dwarf2_find_line_info =
1420         (struct dwarf2_debug*) bfd_zalloc (abfd, sizeof (struct dwarf2_debug));
1421
1422       if (! stash)
1423         return false;
1424
1425       msec = bfd_get_section_by_name (abfd, ".debug_info");
1426       if (! msec)
1427         {
1428           /* No dwarf2 info.  Note that at this point the stash
1429              has been allocated, but contains zeros, this lets
1430              future calls to this function fail quicker. */
1431           return false;
1432         }
1433
1434       size = bfd_get_section_size_before_reloc (msec);
1435       if (size == 0)
1436         return false;
1437
1438       stash->info_ptr = (char *) bfd_alloc (abfd, size);
1439
1440       if (! stash->info_ptr)
1441         return false;
1442
1443       if (! bfd_get_section_contents (abfd, msec, stash->info_ptr, 0, size))
1444         {
1445           stash->info_ptr = 0;
1446           return false;
1447         }
1448
1449       stash->info_ptr_end = stash->info_ptr + size;
1450
1451       /* FIXME: There is a problem with the contents of the
1452          .debug_info section.  The 'low' and 'high' addresses of the
1453          comp_units are computed by relocs against symbols in the
1454          .text segment.  We need these addresses in order to determine
1455          the nearest line number, and so we have to resolve the
1456          relocs.  There is a similar problem when the .debug_line
1457          section is processed as well (e.g., there may be relocs
1458          against the operand of the DW_LNE_set_address operator).
1459
1460          Unfortunately getting hold of the reloc information is hard...
1461
1462          For now, this means that disassembling object files (as
1463          opposed to fully executables) does not always work as well as
1464          we would like.  */
1465     }
1466
1467   /* A null info_ptr indicates that there is no dwarf2 info
1468      (or that an error occured while setting up the stash). */
1469
1470   if (! stash->info_ptr)
1471     return false;
1472
1473   /* Check the previously read comp. units first. */
1474
1475   for (each = stash->all_comp_units; each; each = each->next_unit)
1476     {
1477       if (each->high > 0)
1478         {
1479           if (comp_unit_contains_address (each, addr))
1480             return comp_unit_find_nearest_line (each, addr,
1481                                                 filename_ptr,
1482                                                 functionname_ptr,
1483                                                 linenumber_ptr);
1484         }
1485       else
1486         {
1487           found = comp_unit_find_nearest_line (each, addr,
1488                                                 filename_ptr,
1489                                                 functionname_ptr,
1490                                                 linenumber_ptr);
1491           if (found)
1492             return true;
1493         }
1494     }
1495
1496   /* Read each remaining comp. units checking each as they are read. */
1497   while (stash->info_ptr < stash->info_ptr_end)
1498     {
1499       struct comp_unit* each;
1500       unsigned int length;
1501
1502       length = read_4_bytes (abfd, stash->info_ptr);
1503       stash->info_ptr += 4;
1504
1505       if (length > 0)
1506         {
1507           each = parse_comp_unit (abfd, stash->info_ptr,
1508                                   stash->info_ptr + length);
1509           stash->info_ptr += length;
1510
1511           if (each)
1512             {
1513               each->next_unit = stash->all_comp_units;
1514               stash->all_comp_units = each;
1515
1516               /* DW_AT_low_pc and DW_AT_high_pc are optional for
1517                  compilation units.  If we don't have them (i.e.,
1518                  unit->high == 0), we need to consult the line info
1519                  table to see if a compilation unit contains the given
1520                  address. */
1521               if (each->high > 0)
1522                 {
1523                   if (comp_unit_contains_address (each, addr))
1524                     return comp_unit_find_nearest_line (each, addr,
1525                                                        filename_ptr,
1526                                                        functionname_ptr,
1527                                                        linenumber_ptr);
1528                 }
1529               else
1530                 {
1531                   found = comp_unit_find_nearest_line (each, addr,
1532                                                        filename_ptr,
1533                                                        functionname_ptr,
1534                                                        linenumber_ptr);
1535                   if (found)
1536                     return true;
1537                 }
1538             }
1539         }
1540     }
1541
1542   return false;
1543 }
1544
1545 /* end of file */