gold/dwarf_reader.h

   1 // dwarf_reader.h -- parse dwarf2/3 debug information for gold  -*- C++ -*-
   2
   3 // Copyright 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@google.com>.
   5
   6 // This file is part of gold.
   7
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 3 of the License, or
  11 // (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 // MA 02110-1301, USA.
  22
  23 #ifndef GOLD_DWARF_READER_H
  24 #define GOLD_DWARF_READER_H
  25
  26 #include <vector>
  27 #include <map>
  28 #include <limits.h>
  29 #include <sys/types.h>
  30
  31 #include "elfcpp.h"
  32 #include "elfcpp_swap.h"
  33 #include "dwarf.h"
  34 #include "reloc.h"
  35
  36 namespace gold
  37 {
  38
  39 class Dwarf_info_reader;
  40 struct LineStateMachine;
  41
  42 // This class is used to extract the section index and offset of
  43 // the target of a relocation for a given offset within the section.
  44
  45 class Elf_reloc_mapper
  46 {
  47  public:
  48   Elf_reloc_mapper()
  49   { }
  50
  51   virtual
  52   ~Elf_reloc_mapper()
  53   { }
  54
  55   // Initialize the relocation tracker for section RELOC_SHNDX.
  56   bool
  57   initialize(unsigned int reloc_shndx, unsigned int reloc_type)
  58   { return this->do_initialize(reloc_shndx, reloc_type); }
  59
  60   // Return the next reloc_offset.
  61   off_t
  62   next_offset()
  63   { return this->do_next_offset(); }
  64
  65   // Advance to the next relocation past OFFSET.
  66   void
  67   advance(off_t offset)
  68   { this->do_advance(offset); }
  69
  70   // Return the section index and offset within the section of the target
  71   // of the relocation for RELOC_OFFSET in the referring section.
  72   unsigned int
  73   get_reloc_target(off_t reloc_offset, off_t* target_offset)
  74   { return this->do_get_reloc_target(reloc_offset, target_offset); }
  75
  76   // Checkpoint the current position in the reloc section.
  77   uint64_t
  78   checkpoint() const
  79   { return this->do_checkpoint(); }
  80
  81   // Reset the current position to the CHECKPOINT.
  82   void
  83   reset(uint64_t checkpoint)
  84   { this->do_reset(checkpoint); }
  85
  86  protected:
  87   virtual bool
  88   do_initialize(unsigned int, unsigned int) = 0;
  89
  90   // Return the next reloc_offset.
  91   virtual off_t
  92   do_next_offset() = 0;
  93
  94   // Advance to the next relocation past OFFSET.
  95   virtual void
  96   do_advance(off_t offset) = 0;
  97
  98   virtual unsigned int
  99   do_get_reloc_target(off_t reloc_offset, off_t* target_offset) = 0;
 100
 101   // Checkpoint the current position in the reloc section.
 102   virtual uint64_t
 103   do_checkpoint() const = 0;
 104
 105   // Reset the current position to the CHECKPOINT.
 106   virtual void
 107   do_reset(uint64_t checkpoint) = 0;
 108 };
 109
 110 template<int size, bool big_endian>
 111 class Sized_elf_reloc_mapper : public Elf_reloc_mapper
 112 {
 113  public:
 114   Sized_elf_reloc_mapper(Object* object, const unsigned char* symtab,
 115                          off_t symtab_size)
 116     : object_(object), symtab_(symtab), symtab_size_(symtab_size),
 117       reloc_type_(0), track_relocs_()
 118   { }
 119
 120  protected:
 121   bool
 122   do_initialize(unsigned int reloc_shndx, unsigned int reloc_type);
 123
 124   // Return the next reloc_offset.
 125   virtual off_t
 126   do_next_offset()
 127   { return this->track_relocs_.next_offset(); }
 128
 129   // Advance to the next relocation past OFFSET.
 130   virtual void
 131   do_advance(off_t offset)
 132   { this->track_relocs_.advance(offset); }
 133
 134   unsigned int
 135   do_get_reloc_target(off_t reloc_offset, off_t* target_offset);
 136
 137   // Checkpoint the current position in the reloc section.
 138   uint64_t
 139   do_checkpoint() const
 140   { return this->track_relocs_.checkpoint(); }
 141
 142   // Reset the current position to the CHECKPOINT.
 143   void
 144   do_reset(uint64_t checkpoint)
 145   { this->track_relocs_.reset(checkpoint); }
 146
 147  private:
 148   typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
 149
 150   // Return the section index of symbol SYMNDX, and copy its value to *VALUE.
 151   // Set *IS_ORDINARY true if the section index is an ordinary section index.
 152   unsigned int
 153   symbol_section(unsigned int symndx, Address* value, bool* is_ordinary);
 154
 155   // The object file.
 156   Object* object_;
 157   // The ELF symbol table.
 158   const unsigned char* symtab_;
 159   // The size of the ELF symbol table.
 160   off_t symtab_size_;
 161   // Type of the relocation section (SHT_REL or SHT_RELA).
 162   unsigned int reloc_type_;
 163   // Relocations for the referring section.
 164   Track_relocs<size, big_endian> track_relocs_;
 165 };
 166
 167 // This class is used to read the abbreviations table from the
 168 // .debug_abbrev section of the object file.
 169
 170 class Dwarf_abbrev_table
 171 {
 172  public:
 173   // An attribute list entry.
 174   struct Attribute
 175   {
 176     Attribute(unsigned int a, unsigned int f)
 177       : attr(a), form(f)
 178     { }
 179     unsigned int attr;
 180     unsigned int form;
 181   };
 182
 183   // An abbrev code entry.
 184   struct Abbrev_code
 185   {
 186     Abbrev_code(unsigned int t, bool hc)
 187       : tag(t), has_children(hc), has_sibling_attribute(false), attributes()
 188     {
 189       this->attributes.reserve(10);
 190     }
 191
 192     void
 193     add_attribute(unsigned int attr, unsigned int form)
 194     {
 195       this->attributes.push_back(Attribute(attr, form));
 196     }
 197
 198     // The DWARF tag.
 199     unsigned int tag;
 200     // True if the DIE has children.
 201     bool has_children : 1;
 202     // True if the DIE has a sibling attribute.
 203     bool has_sibling_attribute : 1;
 204     // The list of attributes and forms.
 205     std::vector<Attribute> attributes;
 206   };
 207
 208   Dwarf_abbrev_table()
 209     : abbrev_shndx_(0), abbrev_offset_(0), buffer_(NULL), buffer_end_(NULL),
 210       owns_buffer_(false), buffer_pos_(NULL), high_abbrev_codes_()
 211   {
 212     memset(this->low_abbrev_codes_, 0, sizeof(this->low_abbrev_codes_));
 213   }
 214
 215   ~Dwarf_abbrev_table()
 216   {
 217     if (this->owns_buffer_ && this->buffer_ != NULL)
 218       delete[] this->buffer_;
 219     this->clear_abbrev_codes();
 220   }
 221
 222   // Read the abbrev table from an object file.
 223   bool
 224   read_abbrevs(Relobj* object,
 225                unsigned int abbrev_shndx,
 226                off_t abbrev_offset)
 227   {
 228     // If we've already read this abbrev table, return immediately.
 229     if (this->abbrev_shndx_ > 0
 230         && this->abbrev_shndx_ == abbrev_shndx
 231         && this->abbrev_offset_ == abbrev_offset)
 232       return true;
 233     return this->do_read_abbrevs(object, abbrev_shndx, abbrev_offset);
 234   }
 235
 236   // Return the abbrev code entry for CODE.  This is a fast path for
 237   // abbrev codes that are in the direct lookup table.  If not found
 238   // there, we call do_get_abbrev() to do the hard work.
 239   const Abbrev_code*
 240   get_abbrev(unsigned int code)
 241   {
 242     if (code < this->low_abbrev_code_max_
 243         && this->low_abbrev_codes_[code] != NULL)
 244       return this->low_abbrev_codes_[code];
 245     return this->do_get_abbrev(code);
 246   }
 247
 248  private:
 249   // Read the abbrev table from an object file.
 250   bool
 251   do_read_abbrevs(Relobj* object,
 252                   unsigned int abbrev_shndx,
 253                   off_t abbrev_offset);
 254
 255   // Lookup the abbrev code entry for CODE.
 256   const Abbrev_code*
 257   do_get_abbrev(unsigned int code);
 258
 259   // Store an abbrev code entry for CODE.
 260   void
 261   store_abbrev(unsigned int code, const Abbrev_code* entry)
 262   {
 263     if (code < this->low_abbrev_code_max_)
 264       this->low_abbrev_codes_[code] = entry;
 265     else
 266       this->high_abbrev_codes_[code] = entry;
 267   }
 268
 269   // Clear the abbrev code table and release the memory it uses.
 270   void
 271   clear_abbrev_codes();
 272
 273   typedef Unordered_map<unsigned int, const Abbrev_code*> Abbrev_code_table;
 274
 275   // The section index of the current abbrev table.
 276   unsigned int abbrev_shndx_;
 277   // The offset within the section of the current abbrev table.
 278   off_t abbrev_offset_;
 279   // The buffer containing the .debug_abbrev section.
 280   const unsigned char* buffer_;
 281   const unsigned char* buffer_end_;
 282   // True if this object owns the buffer and needs to delete it.
 283   bool owns_buffer_;
 284   // Pointer to the current position in the buffer.
 285   const unsigned char* buffer_pos_;
 286   // The table of abbrev codes.
 287   // We use a direct-lookup array for low abbrev codes,
 288   // and store the rest in a hash table.
 289   static const unsigned int low_abbrev_code_max_ = 256;
 290   const Abbrev_code* low_abbrev_codes_[low_abbrev_code_max_];
 291   Abbrev_code_table high_abbrev_codes_;
 292 };
 293
 294 // A DWARF range list.  The start and end offsets are relative
 295 // to the input section SHNDX.  Each range must lie entirely
 296 // within a single section.
 297
 298 class Dwarf_range_list
 299 {
 300  public:
 301   struct Range
 302   {
 303     Range(unsigned int a_shndx, off_t a_start, off_t a_end)
 304       : shndx(a_shndx), start(a_start), end(a_end)
 305     { }
 306
 307     unsigned int shndx;
 308     off_t start;
 309     off_t end;
 310   };
 311
 312   Dwarf_range_list()
 313     : range_list_()
 314   { }
 315
 316   void
 317   add(unsigned int shndx, off_t start, off_t end)
 318   { this->range_list_.push_back(Range(shndx, start, end)); }
 319
 320   size_t
 321   size() const
 322   { return this->range_list_.size(); }
 323
 324   const Range&
 325   operator[](off_t i) const
 326   { return this->range_list_[i]; }
 327
 328  private:
 329   std::vector<Range> range_list_;
 330 };
 331
 332 // This class is used to read the ranges table from the
 333 // .debug_ranges section of the object file.
 334
 335 class Dwarf_ranges_table
 336 {
 337  public:
 338   Dwarf_ranges_table(Dwarf_info_reader* dwinfo)
 339     : dwinfo_(dwinfo), ranges_shndx_(0), ranges_buffer_(NULL),
 340       ranges_buffer_end_(NULL), owns_ranges_buffer_(false),
 341       ranges_reloc_mapper_(NULL), reloc_type_(0), output_section_offset_(0)
 342   { }
 343
 344   ~Dwarf_ranges_table()
 345   {
 346     if (this->owns_ranges_buffer_ && this->ranges_buffer_ != NULL)
 347       delete[] this->ranges_buffer_;
 348     if (this->ranges_reloc_mapper_ != NULL)
 349       delete this->ranges_reloc_mapper_;
 350   }
 351
 352   // Read the ranges table from an object file.
 353   bool
 354   read_ranges_table(Relobj* object,
 355                     const unsigned char* symtab,
 356                     off_t symtab_size,
 357                     unsigned int ranges_shndx);
 358
 359   // Read the range table from an object file.
 360   Dwarf_range_list*
 361   read_range_list(Relobj* object,
 362                   const unsigned char* symtab,
 363                   off_t symtab_size,
 364                   unsigned int address_size,
 365                   unsigned int ranges_shndx,
 366                   off_t ranges_offset);
 367
 368   // Look for a relocation at offset OFF in the range table,
 369   // and return the section index and offset of the target.
 370   unsigned int
 371   lookup_reloc(off_t off, off_t* target_off);
 372
 373  private:
 374   // The Dwarf_info_reader, for reading data.
 375   Dwarf_info_reader* dwinfo_;
 376   // The section index of the ranges table.
 377   unsigned int ranges_shndx_;
 378   // The buffer containing the .debug_ranges section.
 379   const unsigned char* ranges_buffer_;
 380   const unsigned char* ranges_buffer_end_;
 381   // True if this object owns the buffer and needs to delete it.
 382   bool owns_ranges_buffer_;
 383   // Relocation mapper for the .debug_ranges section.
 384   Elf_reloc_mapper* ranges_reloc_mapper_;
 385   // Type of the relocation section (SHT_REL or SHT_RELA).
 386   unsigned int reloc_type_;
 387   // For incremental update links, this will hold the offset of the
 388   // input section within the output section.  Offsets read from
 389   // relocated data will be relative to the output section, and need
 390   // to be corrected before reading data from the input section.
 391   uint64_t output_section_offset_;
 392 };
 393
 394 // This class is used to read the pubnames and pubtypes tables from the
 395 // .debug_pubnames and .debug_pubtypes sections of the object file.
 396
 397 class Dwarf_pubnames_table
 398 {
 399  public:
 400   Dwarf_pubnames_table(Dwarf_info_reader* dwinfo, bool is_pubtypes)
 401     : dwinfo_(dwinfo), buffer_(NULL), buffer_end_(NULL), owns_buffer_(false),
 402       offset_size_(0), pinfo_(NULL), is_pubtypes_(is_pubtypes),
 403       output_section_offset_(0), unit_length_(0), cu_offset_(0)
 404   { }
 405
 406   ~Dwarf_pubnames_table()
 407   {
 408     if (this->owns_buffer_ && this->buffer_ != NULL)
 409       delete[] this->buffer_;
 410   }
 411
 412   // Read the pubnames section from the object file, using the symbol
 413   // table for relocating it.
 414   bool
 415   read_section(Relobj* object, const unsigned char* symbol_table,
 416                off_t symtab_size);
 417
 418   // Read the header for the set at OFFSET.
 419   bool
 420   read_header(off_t offset);
 421
 422   // Return the offset to the cu within the info or types section.
 423   off_t
 424   cu_offset()
 425   { return this->cu_offset_; }
 426
 427   // Return the size of this subsection of the table.  The unit length
 428   // doesn't include the size of its own field.
 429   off_t
 430   subsection_size()
 431   { return this->unit_length_; }
 432
 433   // Read the next name from the set.
 434   const char*
 435   next_name();
 436
 437  private:
 438   // The Dwarf_info_reader, for reading data.
 439   Dwarf_info_reader* dwinfo_;
 440   // The buffer containing the .debug_ranges section.
 441   const unsigned char* buffer_;
 442   const unsigned char* buffer_end_;
 443   // True if this object owns the buffer and needs to delete it.
 444   bool owns_buffer_;
 445   // The size of a DWARF offset for the current set.
 446   unsigned int offset_size_;
 447   // The current position within the buffer.
 448   const unsigned char* pinfo_;
 449   // TRUE if this is a .debug_pubtypes section.
 450   bool is_pubtypes_;
 451   // For incremental update links, this will hold the offset of the
 452   // input section within the output section.  Offsets read from
 453   // relocated data will be relative to the output section, and need
 454   // to be corrected before reading data from the input section.
 455   uint64_t output_section_offset_;
 456   // Fields read from the header.
 457   uint64_t unit_length_;
 458   off_t cu_offset_;
 459
 460   // Track relocations for this table so we can find the CUs that
 461   // correspond to the subsections.
 462   Elf_reloc_mapper* reloc_mapper_;
 463   // Type of the relocation section (SHT_REL or SHT_RELA).
 464   unsigned int reloc_type_;
 465 };
 466
 467 // This class represents a DWARF Debug Info Entry (DIE).
 468
 469 class Dwarf_die
 470 {
 471  public:
 472   // An attribute value.
 473   struct Attribute_value
 474   {
 475     unsigned int attr;
 476     unsigned int form;
 477     union
 478     {
 479       int64_t intval;
 480       uint64_t uintval;
 481       const char* stringval;
 482       const unsigned char* blockval;
 483       off_t refval;
 484     } val;
 485     union
 486     {
 487       // Section index for reference forms.
 488       unsigned int shndx;
 489       // Block length for block forms.
 490       unsigned int blocklen;
 491       // Attribute offset for DW_FORM_strp.
 492       unsigned int attr_off;
 493     } aux;
 494   };
 495
 496   // A list of attribute values.
 497   typedef std::vector<Attribute_value> Attributes;
 498
 499   Dwarf_die(Dwarf_info_reader* dwinfo,
 500             off_t die_offset,
 501             Dwarf_die* parent);
 502
 503   // Return the DWARF tag for this DIE.
 504   unsigned int
 505   tag() const
 506   {
 507     if (this->abbrev_code_ == NULL)
 508       return 0;
 509     return this->abbrev_code_->tag;
 510   }
 511
 512   // Return true if this DIE has children.
 513   bool
 514   has_children() const
 515   {
 516     gold_assert(this->abbrev_code_ != NULL);
 517     return this->abbrev_code_->has_children;
 518   }
 519
 520   // Return true if this DIE has a sibling attribute.
 521   bool
 522   has_sibling_attribute() const
 523   {
 524     gold_assert(this->abbrev_code_ != NULL);
 525     return this->abbrev_code_->has_sibling_attribute;
 526   }
 527
 528   // Return the value of attribute ATTR.
 529   const Attribute_value*
 530   attribute(unsigned int attr);
 531
 532   // Return the value of the DW_AT_name attribute.
 533   const char*
 534   name()
 535   {
 536     if (this->name_ == NULL)
 537       this->set_name();
 538     return this->name_;
 539   }
 540
 541   // Return the value of the DW_AT_linkage_name
 542   // or DW_AT_MIPS_linkage_name attribute.
 543   const char*
 544   linkage_name()
 545   {
 546     if (this->linkage_name_ == NULL)
 547       this->set_linkage_name();
 548     return this->linkage_name_;
 549   }
 550
 551   // Return the value of the DW_AT_specification attribute.
 552   off_t
 553   specification()
 554   {
 555     if (!this->attributes_read_)
 556       this->read_attributes();
 557     return this->specification_;
 558   }
 559
 560   // Return the value of the DW_AT_abstract_origin attribute.
 561   off_t
 562   abstract_origin()
 563   {
 564     if (!this->attributes_read_)
 565       this->read_attributes();
 566     return this->abstract_origin_;
 567   }
 568
 569   // Return the value of attribute ATTR as a string.
 570   const char*
 571   string_attribute(unsigned int attr);
 572
 573   // Return the value of attribute ATTR as an integer.
 574   int64_t
 575   int_attribute(unsigned int attr);
 576
 577   // Return the value of attribute ATTR as an unsigned integer.
 578   uint64_t
 579   uint_attribute(unsigned int attr);
 580
 581   // Return the value of attribute ATTR as a reference.
 582   off_t
 583   ref_attribute(unsigned int attr, unsigned int* shndx);
 584
 585   // Return the value of attribute ATTR as a address.
 586   off_t
 587   address_attribute(unsigned int attr, unsigned int* shndx);
 588
 589   // Return the value of attribute ATTR as a flag.
 590   bool
 591   flag_attribute(unsigned int attr)
 592   { return this->int_attribute(attr) != 0; }
 593
 594   // Return true if this DIE is a declaration.
 595   bool
 596   is_declaration()
 597   { return this->flag_attribute(elfcpp::DW_AT_declaration); }
 598
 599   // Return the parent of this DIE.
 600   Dwarf_die*
 601   parent() const
 602   { return this->parent_; }
 603
 604   // Return the offset of this DIE.
 605   off_t
 606   offset() const
 607   { return this->die_offset_; }
 608
 609   // Return the offset of this DIE's first child.
 610   off_t
 611   child_offset();
 612
 613   // Set the offset of this DIE's next sibling.
 614   void
 615   set_sibling_offset(off_t sibling_offset)
 616   { this->sibling_offset_ = sibling_offset; }
 617
 618   // Return the offset of this DIE's next sibling.
 619   off_t
 620   sibling_offset();
 621
 622  private:
 623   typedef Dwarf_abbrev_table::Abbrev_code Abbrev_code;
 624
 625   // Read all the attributes of the DIE.
 626   bool
 627   read_attributes();
 628
 629   // Set the name of the DIE if present.
 630   void
 631   set_name();
 632
 633   // Set the linkage name if present.
 634   void
 635   set_linkage_name();
 636
 637   // Skip all the attributes of the DIE and return the offset
 638   // of the next DIE.
 639   off_t
 640   skip_attributes();
 641
 642   // The Dwarf_info_reader, for reading attributes.
 643   Dwarf_info_reader* dwinfo_;
 644   // The parent of this DIE.
 645   Dwarf_die* parent_;
 646   // Offset of this DIE within its compilation unit.
 647   off_t die_offset_;
 648   // Offset of the first attribute, relative to the beginning of the DIE.
 649   off_t attr_offset_;
 650   // Offset of the first child, relative to the compilation unit.
 651   off_t child_offset_;
 652   // Offset of the next sibling, relative to the compilation unit.
 653   off_t sibling_offset_;
 654   // The abbreviation table entry.
 655   const Abbrev_code* abbrev_code_;
 656   // The list of attributes.
 657   Attributes attributes_;
 658   // True if the attributes have been read.
 659   bool attributes_read_;
 660   // The following fields hold common attributes to avoid a linear
 661   // search through the attribute list.
 662   // The DIE name (DW_AT_name).
 663   const char* name_;
 664   // Offset of the name in the string table (for DW_FORM_strp).
 665   off_t name_off_;
 666   // The linkage name (DW_AT_linkage_name or DW_AT_MIPS_linkage_name).
 667   const char* linkage_name_;
 668   // Offset of the linkage name in the string table (for DW_FORM_strp).
 669   off_t linkage_name_off_;
 670   // Section index of the string table (for DW_FORM_strp).
 671   unsigned int string_shndx_;
 672   // The value of a DW_AT_specification attribute.
 673   off_t specification_;
 674   // The value of a DW_AT_abstract_origin attribute.
 675   off_t abstract_origin_;
 676 };
 677
 678 // This class is used to read the debug info from the .debug_info
 679 // or .debug_types sections.  This is a base class that implements
 680 // the generic parsing of the compilation unit header and DIE
 681 // structure.  The parse() method parses the entire section, and
 682 // calls the various visit_xxx() methods for each header.  Clients
 683 // should derive a new class from this one and implement the
 684 // visit_compilation_unit() and visit_type_unit() functions.
 685
 686 class Dwarf_info_reader
 687 {
 688  public:
 689   Dwarf_info_reader(bool is_type_unit,
 690                     Relobj* object,
 691                     const unsigned char* symtab,
 692                     off_t symtab_size,
 693                     unsigned int shndx,
 694                     unsigned int reloc_shndx,
 695                     unsigned int reloc_type)
 696     : is_type_unit_(is_type_unit), object_(object), symtab_(symtab),
 697       symtab_size_(symtab_size), shndx_(shndx), reloc_shndx_(reloc_shndx),
 698       reloc_type_(reloc_type), abbrev_shndx_(0), string_shndx_(0),
 699       buffer_(NULL), buffer_end_(NULL), cu_offset_(0), cu_length_(0),
 700       offset_size_(0), address_size_(0), cu_version_(0), type_signature_(0),
 701       type_offset_(0), abbrev_table_(), ranges_table_(this),
 702       reloc_mapper_(NULL), string_buffer_(NULL), string_buffer_end_(NULL),
 703       owns_string_buffer_(false), string_output_section_offset_(0)
 704   { }
 705
 706   virtual
 707   ~Dwarf_info_reader()
 708   {
 709     if (this->reloc_mapper_ != NULL)
 710       delete this->reloc_mapper_;
 711     if (this->owns_string_buffer_ && this->string_buffer_ != NULL)
 712       delete[] this->string_buffer_;
 713   }
 714
 715   // Begin parsing the debug info.  This calls visit_compilation_unit()
 716   // or visit_type_unit() for each compilation or type unit found in the
 717   // section, and visit_die() for each top-level DIE.
 718   void
 719   parse();
 720
 721   // Return the abbrev code entry for a CODE.
 722   const Dwarf_abbrev_table::Abbrev_code*
 723   get_abbrev(unsigned int code)
 724   { return this->abbrev_table_.get_abbrev(code); }
 725
 726   // Return a pointer to the DWARF info buffer at OFFSET.
 727   const unsigned char*
 728   buffer_at_offset(off_t offset) const
 729   {
 730     const unsigned char* p = this->buffer_ + this->cu_offset_ + offset;
 731     if (this->check_buffer(p + 1))
 732       return p;
 733     return NULL;
 734   }
 735
 736   // Read a possibly unaligned integer of SIZE.
 737   template <int valsize>
 738   inline typename elfcpp::Valtype_base<valsize>::Valtype
 739   read_from_pointer(const unsigned char* source);
 740
 741   // Read a possibly unaligned integer of SIZE.  Update SOURCE after read.
 742   template <int valsize>
 743   inline typename elfcpp::Valtype_base<valsize>::Valtype
 744   read_from_pointer(const unsigned char** source);
 745
 746   // Look for a relocation at offset ATTR_OFF in the dwarf info,
 747   // and return the section index and offset of the target.
 748   unsigned int
 749   lookup_reloc(off_t attr_off, off_t* target_off);
 750
 751   // Return a string from the DWARF string table.
 752   const char*
 753   get_string(off_t str_off, unsigned int string_shndx);
 754
 755   // Return the size of a DWARF offset.
 756   unsigned int
 757   offset_size() const
 758   { return this->offset_size_; }
 759
 760   // Return the size of an address.
 761   unsigned int
 762   address_size() const
 763   { return this->address_size_; }
 764
 765   // Set the section index of the .debug_abbrev section.
 766   // We use this if there are no relocations for the .debug_info section.
 767   // If not set, the code parse() routine will search for the section by name.
 768   void
 769   set_abbrev_shndx(unsigned int abbrev_shndx)
 770   { this->abbrev_shndx_ = abbrev_shndx; }
 771
 772   // Return a pointer to the object file's ELF symbol table.
 773   const unsigned char*
 774   symtab() const
 775   { return this->symtab_; }
 776
 777   // Return the size of the object file's ELF symbol table.
 778   off_t
 779   symtab_size() const
 780   { return this->symtab_size_; }
 781
 782   // Return the offset of the current compilation unit.
 783   off_t
 784   cu_offset() const
 785   { return this->cu_offset_; }
 786
 787  protected:
 788   // Begin parsing the debug info.  This calls visit_compilation_unit()
 789   // or visit_type_unit() for each compilation or type unit found in the
 790   // section, and visit_die() for each top-level DIE.
 791   template<bool big_endian>
 792   void
 793   do_parse();
 794
 795   // The following methods are hooks that are meant to be implemented
 796   // by a derived class.  A default, do-nothing, implementation of
 797   // each is provided for this base class.
 798
 799   // Visit a compilation unit.
 800   virtual void
 801   visit_compilation_unit(off_t cu_offset, off_t cu_length, Dwarf_die* root_die);
 802
 803   // Visit a type unit.
 804   virtual void
 805   visit_type_unit(off_t tu_offset, off_t type_offset, uint64_t signature,
 806                   Dwarf_die* root_die);
 807
 808   // Read the range table.
 809   Dwarf_range_list*
 810   read_range_list(unsigned int ranges_shndx, off_t ranges_offset)
 811   {
 812     return this->ranges_table_.read_range_list(this->object_,
 813                                                this->symtab_,
 814                                                this->symtab_size_,
 815                                                this->address_size_,
 816                                                ranges_shndx,
 817                                                ranges_offset);
 818   }
 819
 820   // Return the object.
 821   Relobj*
 822   object() const
 823   { return this->object_; }
 824
 825   // Checkpoint the relocation tracker.
 826   uint64_t
 827   get_reloc_checkpoint() const
 828   { return this->reloc_mapper_->checkpoint(); }
 829
 830   // Reset the relocation tracker to the CHECKPOINT.
 831   void
 832   reset_relocs(uint64_t checkpoint)
 833   { this->reloc_mapper_->reset(checkpoint); }
 834
 835  private:
 836   // Print a warning about a corrupt debug section.
 837   void
 838   warn_corrupt_debug_section() const;
 839
 840   // Check that P is within the bounds of the current section.
 841   bool
 842   check_buffer(const unsigned char* p) const
 843   {
 844     if (p > this->buffer_ + this->cu_offset_ + this->cu_length_)
 845       {
 846         this->warn_corrupt_debug_section();
 847         return false;
 848       }
 849     return true;
 850   }
 851
 852   // Read the DWARF string table.
 853   bool
 854   read_string_table(unsigned int string_shndx)
 855   {
 856     // If we've already read this string table, return immediately.
 857     if (this->string_shndx_ > 0 && this->string_shndx_ == string_shndx)
 858       return true;
 859     if (string_shndx == 0 && this->string_shndx_ > 0)
 860       return true;
 861     return this->do_read_string_table(string_shndx);
 862   }
 863
 864   bool
 865   do_read_string_table(unsigned int string_shndx);
 866
 867   // True if this is a type unit; false for a compilation unit.
 868   bool is_type_unit_;
 869   // The object containing the .debug_info or .debug_types input section.
 870   Relobj* object_;
 871   // The ELF symbol table.
 872   const unsigned char* symtab_;
 873   // The size of the ELF symbol table.
 874   off_t symtab_size_;
 875   // Index of the .debug_info or .debug_types section.
 876   unsigned int shndx_;
 877   // Index of the relocation section.
 878   unsigned int reloc_shndx_;
 879   // Type of the relocation section (SHT_REL or SHT_RELA).
 880   unsigned int reloc_type_;
 881   // Index of the .debug_abbrev section (0 if not known).
 882   unsigned int abbrev_shndx_;
 883   // Index of the .debug_str section.
 884   unsigned int string_shndx_;
 885   // The buffer for the debug info.
 886   const unsigned char* buffer_;
 887   const unsigned char* buffer_end_;
 888   // Offset of the current compilation unit.
 889   off_t cu_offset_;
 890   // Length of the current compilation unit.
 891   off_t cu_length_;
 892   // Size of a DWARF offset for the current compilation unit.
 893   unsigned int offset_size_;
 894   // Size of an address for the target architecture.
 895   unsigned int address_size_;
 896   // Compilation unit version number.
 897   unsigned int cu_version_;
 898   // Type signature (for a type unit).
 899   uint64_t type_signature_;
 900   // Offset from the type unit header to the type DIE (for a type unit).
 901   off_t type_offset_;
 902   // Abbreviations table for current compilation unit.
 903   Dwarf_abbrev_table abbrev_table_;
 904   // Ranges table for the current compilation unit.
 905   Dwarf_ranges_table ranges_table_;
 906   // Relocation mapper for the section.
 907   Elf_reloc_mapper* reloc_mapper_;
 908   // The buffer for the debug string table.
 909   const char* string_buffer_;
 910   const char* string_buffer_end_;
 911   // True if this object owns the buffer and needs to delete it.
 912   bool owns_string_buffer_;
 913   // For incremental update links, this will hold the offset of the
 914   // input .debug_str section within the output section.  Offsets read
 915   // from relocated data will be relative to the output section, and need
 916   // to be corrected before reading data from the input section.
 917   uint64_t string_output_section_offset_;
 918 };
 919
 920 // We can't do better than to keep the offsets in a sorted vector.
 921 // Here, offset is the key, and file_num/line_num is the value.
 922 struct Offset_to_lineno_entry
 923 {
 924   off_t offset;
 925   int header_num;  // which file-list to use (i.e. which .o file are we in)
 926   // A pointer into files_.
 927   unsigned int file_num : sizeof(int) * CHAR_BIT - 1;
 928   // True if this was the last entry for the current offset, meaning
 929   // it's the line that actually applies.
 930   unsigned int last_line_for_offset : 1;
 931   // The line number in the source file.  -1 to indicate end-of-function.
 932   int line_num;
 933
 934   // This sorts by offsets first, and then puts the correct line to
 935   // report for a given offset at the beginning of the run of equal
 936   // offsets (so that asking for 1 line gives the best answer).  This
 937   // is not a total ordering.
 938   bool operator<(const Offset_to_lineno_entry& that) const
 939   {
 940     if (this->offset != that.offset)
 941       return this->offset < that.offset;
 942     // Note the '>' which makes this sort 'true' first.
 943     return this->last_line_for_offset > that.last_line_for_offset;
 944   }
 945 };
 946
 947 // This class is used to read the line information from the debugging
 948 // section of an object file.
 949
 950 class Dwarf_line_info
 951 {
 952  public:
 953   Dwarf_line_info()
 954   { }
 955
 956   virtual
 957   ~Dwarf_line_info()
 958   { }
 959
 960   // Given a section number and an offset, returns the associated
 961   // file and line-number, as a string: "file:lineno".  If unable
 962   // to do the mapping, returns the empty string.  You must call
 963   // read_line_mappings() before calling this function.  If
 964   // 'other_lines' is non-NULL, fills that in with other line
 965   // numbers assigned to the same offset.
 966   std::string
 967   addr2line(unsigned int shndx, off_t offset,
 968             std::vector<std::string>* other_lines)
 969   { return this->do_addr2line(shndx, offset, other_lines); }
 970
 971   // A helper function for a single addr2line lookup.  It also keeps a
 972   // cache of the last CACHE_SIZE Dwarf_line_info objects it created;
 973   // set to 0 not to cache at all.  The larger CACHE_SIZE is, the more
 974   // chance this routine won't have to re-create a Dwarf_line_info
 975   // object for its addr2line computation; such creations are slow.
 976   // NOTE: Not thread-safe, so only call from one thread at a time.
 977   static std::string
 978   one_addr2line(Object* object, unsigned int shndx, off_t offset,
 979                 size_t cache_size, std::vector<std::string>* other_lines);
 980
 981   // This reclaims all the memory that one_addr2line may have cached.
 982   // Use this when you know you will not be calling one_addr2line again.
 983   static void
 984   clear_addr2line_cache();
 985
 986  private:
 987   virtual std::string
 988   do_addr2line(unsigned int shndx, off_t offset,
 989                std::vector<std::string>* other_lines) = 0;
 990 };
 991
 992 template<int size, bool big_endian>
 993 class Sized_dwarf_line_info : public Dwarf_line_info
 994 {
 995  public:
 996   // Initializes a .debug_line reader for a given object file.
 997   // If SHNDX is specified and non-negative, only read the debug
 998   // information that pertains to the specified section.
 999   Sized_dwarf_line_info(Object* object, unsigned int read_shndx = -1U);
1000
1001   virtual
1002   ~Sized_dwarf_line_info()
1003   {
1004     if (this->buffer_start_ != NULL)
1005       delete[] this->buffer_start_;
1006   }
1007
1008  private:
1009   std::string
1010   do_addr2line(unsigned int shndx, off_t offset,
1011                std::vector<std::string>* other_lines);
1012
1013   // Formats a file and line number to a string like "dirname/filename:lineno".
1014   std::string
1015   format_file_lineno(const Offset_to_lineno_entry& lineno) const;
1016
1017   // Start processing line info, and populates the offset_map_.
1018   // If SHNDX is non-negative, only store debug information that
1019   // pertains to the specified section.
1020   void
1021   read_line_mappings(unsigned int shndx);
1022
1023   // Reads the relocation section associated with .debug_line and
1024   // stores relocation information in reloc_map_.
1025   void
1026   read_relocs();
1027
1028   // Reads the DWARF2/3 header for this line info.  Each takes as input
1029   // a starting buffer position, and returns the ending position.
1030   const unsigned char*
1031   read_header_prolog(const unsigned char* lineptr);
1032
1033   const unsigned char*
1034   read_header_tables(const unsigned char* lineptr);
1035
1036   // Reads the DWARF2/3 line information.  If shndx is non-negative,
1037   // discard all line information that doesn't pertain to the given
1038   // section.
1039   const unsigned char*
1040   read_lines(const unsigned char* lineptr, unsigned int shndx);
1041
1042   // Process a single line info opcode at START using the state
1043   // machine at LSM.  Return true if we should define a line using the
1044   // current state of the line state machine.  Place the length of the
1045   // opcode in LEN.
1046   bool
1047   process_one_opcode(const unsigned char* start,
1048                      struct LineStateMachine* lsm, size_t* len);
1049
1050   // Some parts of processing differ depending on whether the input
1051   // was a .o file or not.
1052   bool input_is_relobj();
1053
1054   // If we saw anything amiss while parsing, we set this to false.
1055   // Then addr2line will always fail (rather than return possibly-
1056   // corrupt data).
1057   bool data_valid_;
1058
1059   // A DWARF2/3 line info header.  This is not the same size as in the
1060   // actual file, as the one in the file may have a 32 bit or 64 bit
1061   // lengths.
1062
1063   struct Dwarf_line_infoHeader
1064   {
1065     off_t total_length;
1066     int version;
1067     off_t prologue_length;
1068     int min_insn_length; // insn stands for instructin
1069     bool default_is_stmt; // stmt stands for statement
1070     signed char line_base;
1071     int line_range;
1072     unsigned char opcode_base;
1073     std::vector<unsigned char> std_opcode_lengths;
1074     int offset_size;
1075   } header_;
1076
1077   // buffer is the buffer for our line info, starting at exactly where
1078   // the line info to read is.
1079   const unsigned char* buffer_;
1080   const unsigned char* buffer_end_;
1081   // If the buffer was allocated temporarily, and therefore must be
1082   // deallocated in the dtor, this contains a pointer to the start
1083   // of the buffer.
1084   const unsigned char* buffer_start_;
1085
1086   // This has relocations that point into buffer.
1087   Sized_elf_reloc_mapper<size, big_endian>* reloc_mapper_;
1088   // The type of the reloc section in track_relocs_--SHT_REL or SHT_RELA.
1089   unsigned int track_relocs_type_;
1090
1091   // This is used to figure out what section to apply a relocation to.
1092   const unsigned char* symtab_buffer_;
1093   section_size_type symtab_buffer_size_;
1094
1095   // Holds the directories and files as we see them.  We have an array
1096   // of directory-lists, one for each .o file we're reading (usually
1097   // there will just be one, but there may be more if input is a .so).
1098   std::vector<std::vector<std::string> > directories_;
1099   // The first part is an index into directories_, the second the filename.
1100   std::vector<std::vector< std::pair<int, std::string> > > files_;
1101
1102   // An index into the current directories_ and files_ vectors.
1103   int current_header_index_;
1104
1105   // A sorted map from offset of the relocation target to the shndx
1106   // and addend for the relocation.
1107   typedef std::map<off_t, std::pair<unsigned int, off_t> >
1108   Reloc_map;
1109   Reloc_map reloc_map_;
1110
1111   // We have a vector of offset->lineno entries for every input section.
1112   typedef Unordered_map<unsigned int, std::vector<Offset_to_lineno_entry> >
1113   Lineno_map;
1114
1115   Lineno_map line_number_map_;
1116 };
1117
1118 } // End namespace gold.
1119
1120 #endif // !defined(GOLD_DWARF_READER_H)