Automatic date update in version.in
[external/binutils.git] / gold / dwarf_reader.h
1 // dwarf_reader.h -- parse dwarf2/3 debug information for gold  -*- C++ -*-
2
3 // Copyright (C) 2007-2019 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), end_of_table_(NULL),
403       is_pubtypes_(is_pubtypes), is_gnu_style_(false),
404       unit_length_(0), cu_offset_(0)
405   { }
406
407   ~Dwarf_pubnames_table()
408   {
409     if (this->owns_buffer_ && this->buffer_ != NULL)
410       delete[] this->buffer_;
411   }
412
413   // Read the pubnames section from the object file, using the symbol
414   // table for relocating it.
415   bool
416   read_section(Relobj* object, const unsigned char* symbol_table,
417                off_t symtab_size);
418
419   // Read the header for the set at OFFSET.
420   bool
421   read_header(off_t offset);
422
423   // Return the offset to the cu within the info or types section.
424   off_t
425   cu_offset()
426   { return this->cu_offset_; }
427
428   // Return the size of this subsection of the table.  The unit length
429   // doesn't include the size of its own field.
430   off_t
431   subsection_size()
432   { return this->unit_length_; }
433
434   // Read the next name from the set.  If the pubname table is gnu-style,
435   // FLAG_BYTE is set to the high-byte of a gdb_index version 7 cu_index.
436   const char*
437   next_name(uint8_t* flag_byte);
438
439  private:
440   // The Dwarf_info_reader, for reading data.
441   Dwarf_info_reader* dwinfo_;
442   // The buffer containing the .debug_ranges section.
443   const unsigned char* buffer_;
444   const unsigned char* buffer_end_;
445   // True if this object owns the buffer and needs to delete it.
446   bool owns_buffer_;
447   // The size of a DWARF offset for the current set.
448   unsigned int offset_size_;
449   // The current position within the buffer.
450   const unsigned char* pinfo_;
451   // The end of the current pubnames table.
452   const unsigned char* end_of_table_;
453   // TRUE if this is a .debug_pubtypes section.
454   bool is_pubtypes_;
455   // Gnu-style pubnames table. This style has an extra flag byte between the
456   // offset and the name, and is used for generating version 7 of gdb-index.
457   bool is_gnu_style_;
458   // Fields read from the header.
459   uint64_t unit_length_;
460   off_t cu_offset_;
461
462   // Track relocations for this table so we can find the CUs that
463   // correspond to the subsections.
464   Elf_reloc_mapper* reloc_mapper_;
465   // Type of the relocation section (SHT_REL or SHT_RELA).
466   unsigned int reloc_type_;
467 };
468
469 // This class represents a DWARF Debug Info Entry (DIE).
470
471 class Dwarf_die
472 {
473  public:
474   // An attribute value.
475   struct Attribute_value
476   {
477     unsigned int attr;
478     unsigned int form;
479     union
480     {
481       int64_t intval;
482       uint64_t uintval;
483       const char* stringval;
484       const unsigned char* blockval;
485       off_t refval;
486     } val;
487     union
488     {
489       // Section index for reference forms.
490       unsigned int shndx;
491       // Block length for block forms.
492       unsigned int blocklen;
493       // Attribute offset for DW_FORM_strp.
494       unsigned int attr_off;
495     } aux;
496   };
497
498   // A list of attribute values.
499   typedef std::vector<Attribute_value> Attributes;
500
501   Dwarf_die(Dwarf_info_reader* dwinfo,
502             off_t die_offset,
503             Dwarf_die* parent);
504
505   // Return the DWARF tag for this DIE.
506   unsigned int
507   tag() const
508   {
509     if (this->abbrev_code_ == NULL)
510       return 0;
511     return this->abbrev_code_->tag;
512   }
513
514   // Return true if this DIE has children.
515   bool
516   has_children() const
517   {
518     gold_assert(this->abbrev_code_ != NULL);
519     return this->abbrev_code_->has_children;
520   }
521
522   // Return true if this DIE has a sibling attribute.
523   bool
524   has_sibling_attribute() const
525   {
526     gold_assert(this->abbrev_code_ != NULL);
527     return this->abbrev_code_->has_sibling_attribute;
528   }
529
530   // Return the value of attribute ATTR.
531   const Attribute_value*
532   attribute(unsigned int attr);
533
534   // Return the value of the DW_AT_name attribute.
535   const char*
536   name()
537   {
538     if (this->name_ == NULL)
539       this->set_name();
540     return this->name_;
541   }
542
543   // Return the value of the DW_AT_linkage_name
544   // or DW_AT_MIPS_linkage_name attribute.
545   const char*
546   linkage_name()
547   {
548     if (this->linkage_name_ == NULL)
549       this->set_linkage_name();
550     return this->linkage_name_;
551   }
552
553   // Return the value of the DW_AT_specification attribute.
554   off_t
555   specification()
556   {
557     if (!this->attributes_read_)
558       this->read_attributes();
559     return this->specification_;
560   }
561
562   // Return the value of the DW_AT_abstract_origin attribute.
563   off_t
564   abstract_origin()
565   {
566     if (!this->attributes_read_)
567       this->read_attributes();
568     return this->abstract_origin_;
569   }
570
571   // Return the value of attribute ATTR as a string.
572   const char*
573   string_attribute(unsigned int attr);
574
575   // Return the value of attribute ATTR as an integer.
576   int64_t
577   int_attribute(unsigned int attr);
578
579   // Return the value of attribute ATTR as an unsigned integer.
580   uint64_t
581   uint_attribute(unsigned int attr);
582
583   // Return the value of attribute ATTR as a reference.
584   off_t
585   ref_attribute(unsigned int attr, unsigned int* shndx);
586
587   // Return the value of attribute ATTR as a address.
588   off_t
589   address_attribute(unsigned int attr, unsigned int* shndx);
590
591   // Return the value of attribute ATTR as a flag.
592   bool
593   flag_attribute(unsigned int attr)
594   { return this->int_attribute(attr) != 0; }
595
596   // Return true if this DIE is a declaration.
597   bool
598   is_declaration()
599   { return this->flag_attribute(elfcpp::DW_AT_declaration); }
600
601   // Return the parent of this DIE.
602   Dwarf_die*
603   parent() const
604   { return this->parent_; }
605
606   // Return the offset of this DIE.
607   off_t
608   offset() const
609   { return this->die_offset_; }
610
611   // Return the offset of this DIE's first child.
612   off_t
613   child_offset();
614
615   // Set the offset of this DIE's next sibling.
616   void
617   set_sibling_offset(off_t sibling_offset)
618   { this->sibling_offset_ = sibling_offset; }
619
620   // Return the offset of this DIE's next sibling.
621   off_t
622   sibling_offset();
623
624  private:
625   typedef Dwarf_abbrev_table::Abbrev_code Abbrev_code;
626
627   // Read all the attributes of the DIE.
628   bool
629   read_attributes();
630
631   // Set the name of the DIE if present.
632   void
633   set_name();
634
635   // Set the linkage name if present.
636   void
637   set_linkage_name();
638
639   // Skip all the attributes of the DIE and return the offset
640   // of the next DIE.
641   off_t
642   skip_attributes();
643
644   // The Dwarf_info_reader, for reading attributes.
645   Dwarf_info_reader* dwinfo_;
646   // The parent of this DIE.
647   Dwarf_die* parent_;
648   // Offset of this DIE within its compilation unit.
649   off_t die_offset_;
650   // Offset of the first attribute, relative to the beginning of the DIE.
651   off_t attr_offset_;
652   // Offset of the first child, relative to the compilation unit.
653   off_t child_offset_;
654   // Offset of the next sibling, relative to the compilation unit.
655   off_t sibling_offset_;
656   // The abbreviation table entry.
657   const Abbrev_code* abbrev_code_;
658   // The list of attributes.
659   Attributes attributes_;
660   // True if the attributes have been read.
661   bool attributes_read_;
662   // The following fields hold common attributes to avoid a linear
663   // search through the attribute list.
664   // The DIE name (DW_AT_name).
665   const char* name_;
666   // Offset of the name in the string table (for DW_FORM_strp).
667   off_t name_off_;
668   // The linkage name (DW_AT_linkage_name or DW_AT_MIPS_linkage_name).
669   const char* linkage_name_;
670   // Offset of the linkage name in the string table (for DW_FORM_strp).
671   off_t linkage_name_off_;
672   // Section index of the string table (for DW_FORM_strp).
673   unsigned int string_shndx_;
674   // The value of a DW_AT_specification attribute.
675   off_t specification_;
676   // The value of a DW_AT_abstract_origin attribute.
677   off_t abstract_origin_;
678 };
679
680 // This class is used to read the debug info from the .debug_info
681 // or .debug_types sections.  This is a base class that implements
682 // the generic parsing of the compilation unit header and DIE
683 // structure.  The parse() method parses the entire section, and
684 // calls the various visit_xxx() methods for each header.  Clients
685 // should derive a new class from this one and implement the
686 // visit_compilation_unit() and visit_type_unit() functions.
687
688 class Dwarf_info_reader
689 {
690  public:
691   Dwarf_info_reader(bool is_type_unit,
692                     Relobj* object,
693                     const unsigned char* symtab,
694                     off_t symtab_size,
695                     unsigned int shndx,
696                     unsigned int reloc_shndx,
697                     unsigned int reloc_type)
698     : is_type_unit_(is_type_unit), object_(object), symtab_(symtab),
699       symtab_size_(symtab_size), shndx_(shndx), reloc_shndx_(reloc_shndx),
700       reloc_type_(reloc_type), abbrev_shndx_(0), string_shndx_(0),
701       buffer_(NULL), buffer_end_(NULL), cu_offset_(0), cu_length_(0),
702       offset_size_(0), address_size_(0), cu_version_(0),
703       abbrev_table_(), ranges_table_(this),
704       reloc_mapper_(NULL), string_buffer_(NULL), string_buffer_end_(NULL),
705       owns_string_buffer_(false), string_output_section_offset_(0)
706   { }
707
708   virtual
709   ~Dwarf_info_reader()
710   {
711     if (this->reloc_mapper_ != NULL)
712       delete this->reloc_mapper_;
713     if (this->owns_string_buffer_ && this->string_buffer_ != NULL)
714       delete[] this->string_buffer_;
715   }
716
717   // Begin parsing the debug info.  This calls visit_compilation_unit()
718   // or visit_type_unit() for each compilation or type unit found in the
719   // section, and visit_die() for each top-level DIE.
720   void
721   parse();
722
723   // Return the abbrev code entry for a CODE.
724   const Dwarf_abbrev_table::Abbrev_code*
725   get_abbrev(unsigned int code)
726   { return this->abbrev_table_.get_abbrev(code); }
727
728   // Return a pointer to the DWARF info buffer at OFFSET.
729   const unsigned char*
730   buffer_at_offset(off_t offset) const
731   {
732     const unsigned char* p = this->buffer_ + this->cu_offset_ + offset;
733     if (this->check_buffer(p + 1))
734       return p;
735     return NULL;
736   }
737
738   // Read a possibly unaligned integer of SIZE.
739   template <int valsize>
740   inline typename elfcpp::Valtype_base<valsize>::Valtype
741   read_from_pointer(const unsigned char* source);
742
743   // Read a possibly unaligned integer of SIZE.  Update SOURCE after read.
744   template <int valsize>
745   inline typename elfcpp::Valtype_base<valsize>::Valtype
746   read_from_pointer(const unsigned char** source);
747
748   // Look for a relocation at offset ATTR_OFF in the dwarf info,
749   // and return the section index and offset of the target.
750   unsigned int
751   lookup_reloc(off_t attr_off, off_t* target_off);
752
753   // Return a string from the DWARF string table.
754   const char*
755   get_string(off_t str_off, unsigned int string_shndx);
756
757   // Return the size of a DWARF offset.
758   unsigned int
759   offset_size() const
760   { return this->offset_size_; }
761
762   // Return the size of an address.
763   unsigned int
764   address_size() const
765   { return this->address_size_; }
766
767   // Return the size of a DW_FORM_ref_addr.
768   // In DWARF v2, this was the size of an address; in DWARF v3 and later,
769   // it is the size of an DWARF offset.
770   unsigned int
771   ref_addr_size() const
772   { return this->cu_version_ > 2 ? this->offset_size_ : this->address_size_; }
773
774   // Set the section index of the .debug_abbrev section.
775   // We use this if there are no relocations for the .debug_info section.
776   // If not set, the code parse() routine will search for the section by name.
777   void
778   set_abbrev_shndx(unsigned int abbrev_shndx)
779   { this->abbrev_shndx_ = abbrev_shndx; }
780
781   // Return a pointer to the object file's ELF symbol table.
782   const unsigned char*
783   symtab() const
784   { return this->symtab_; }
785
786   // Return the size of the object file's ELF symbol table.
787   off_t
788   symtab_size() const
789   { return this->symtab_size_; }
790
791   // Return the offset of the current compilation unit.
792   off_t
793   cu_offset() const
794   { return this->cu_offset_; }
795
796  protected:
797   // Begin parsing the debug info.  This calls visit_compilation_unit()
798   // or visit_type_unit() for each compilation or type unit found in the
799   // section, and visit_die() for each top-level DIE.
800   template<bool big_endian>
801   void
802   do_parse();
803
804   // The following methods are hooks that are meant to be implemented
805   // by a derived class.  A default, do-nothing, implementation of
806   // each is provided for this base class.
807
808   // Visit a compilation unit.
809   virtual void
810   visit_compilation_unit(off_t cu_offset, off_t cu_length, Dwarf_die* root_die);
811
812   // Visit a type unit.
813   virtual void
814   visit_type_unit(off_t tu_offset, off_t tu_length, off_t type_offset,
815                   uint64_t signature, Dwarf_die* root_die);
816
817   // Read the range table.
818   Dwarf_range_list*
819   read_range_list(unsigned int ranges_shndx, off_t ranges_offset)
820   {
821     return this->ranges_table_.read_range_list(this->object_,
822                                                this->symtab_,
823                                                this->symtab_size_,
824                                                this->address_size_,
825                                                ranges_shndx,
826                                                ranges_offset);
827   }
828
829   // Return the object.
830   Relobj*
831   object() const
832   { return this->object_; }
833
834   // Checkpoint the relocation tracker.
835   uint64_t
836   get_reloc_checkpoint() const
837   { return this->reloc_mapper_->checkpoint(); }
838
839   // Reset the relocation tracker to the CHECKPOINT.
840   void
841   reset_relocs(uint64_t checkpoint)
842   { this->reloc_mapper_->reset(checkpoint); }
843
844  private:
845   // Print a warning about a corrupt debug section.
846   void
847   warn_corrupt_debug_section() const;
848
849   // Check that P is within the bounds of the current section.
850   bool
851   check_buffer(const unsigned char* p) const
852   {
853     if (p > this->buffer_ + this->cu_offset_ + this->cu_length_)
854       {
855         this->warn_corrupt_debug_section();
856         return false;
857       }
858     return true;
859   }
860
861   // Read the DWARF string table.
862   bool
863   read_string_table(unsigned int string_shndx)
864   {
865     // If we've already read this string table, return immediately.
866     if (this->string_shndx_ > 0 && this->string_shndx_ == string_shndx)
867       return true;
868     if (string_shndx == 0 && this->string_shndx_ > 0)
869       return true;
870     return this->do_read_string_table(string_shndx);
871   }
872
873   bool
874   do_read_string_table(unsigned int string_shndx);
875
876   // True if this is a type unit; false for a compilation unit.
877   bool is_type_unit_;
878   // The object containing the .debug_info or .debug_types input section.
879   Relobj* object_;
880   // The ELF symbol table.
881   const unsigned char* symtab_;
882   // The size of the ELF symbol table.
883   off_t symtab_size_;
884   // Index of the .debug_info or .debug_types section.
885   unsigned int shndx_;
886   // Index of the relocation section.
887   unsigned int reloc_shndx_;
888   // Type of the relocation section (SHT_REL or SHT_RELA).
889   unsigned int reloc_type_;
890   // Index of the .debug_abbrev section (0 if not known).
891   unsigned int abbrev_shndx_;
892   // Index of the .debug_str section.
893   unsigned int string_shndx_;
894   // The buffer for the debug info.
895   const unsigned char* buffer_;
896   const unsigned char* buffer_end_;
897   // Offset of the current compilation unit.
898   off_t cu_offset_;
899   // Length of the current compilation unit.
900   off_t cu_length_;
901   // Size of a DWARF offset for the current compilation unit.
902   unsigned int offset_size_;
903   // Size of an address for the target architecture.
904   unsigned int address_size_;
905   // Compilation unit version number.
906   unsigned int cu_version_;
907   // Abbreviations table for current compilation unit.
908   Dwarf_abbrev_table abbrev_table_;
909   // Ranges table for the current compilation unit.
910   Dwarf_ranges_table ranges_table_;
911   // Relocation mapper for the section.
912   Elf_reloc_mapper* reloc_mapper_;
913   // The buffer for the debug string table.
914   const char* string_buffer_;
915   const char* string_buffer_end_;
916   // True if this object owns the buffer and needs to delete it.
917   bool owns_string_buffer_;
918   // For incremental update links, this will hold the offset of the
919   // input .debug_str section within the output section.  Offsets read
920   // from relocated data will be relative to the output section, and need
921   // to be corrected before reading data from the input section.
922   uint64_t string_output_section_offset_;
923 };
924
925 // We can't do better than to keep the offsets in a sorted vector.
926 // Here, offset is the key, and file_num/line_num is the value.
927 struct Offset_to_lineno_entry
928 {
929   off_t offset;
930   int header_num;  // which file-list to use (i.e. which .o file are we in)
931   // A pointer into files_.
932   unsigned int file_num : sizeof(int) * CHAR_BIT - 1;
933   // True if this was the last entry for the current offset, meaning
934   // it's the line that actually applies.
935   unsigned int last_line_for_offset : 1;
936   // The line number in the source file.  -1 to indicate end-of-function.
937   int line_num;
938
939   // This sorts by offsets first, and then puts the correct line to
940   // report for a given offset at the beginning of the run of equal
941   // offsets (so that asking for 1 line gives the best answer).  This
942   // is not a total ordering.
943   bool operator<(const Offset_to_lineno_entry& that) const
944   {
945     if (this->offset != that.offset)
946       return this->offset < that.offset;
947     // Note the '>' which makes this sort 'true' first.
948     return this->last_line_for_offset > that.last_line_for_offset;
949   }
950 };
951
952 // This class is used to read the line information from the debugging
953 // section of an object file.
954
955 class Dwarf_line_info
956 {
957  public:
958   Dwarf_line_info()
959   { }
960
961   virtual
962   ~Dwarf_line_info()
963   { }
964
965   // Given a section number and an offset, returns the associated
966   // file and line-number, as a string: "file:lineno".  If unable
967   // to do the mapping, returns the empty string.  You must call
968   // read_line_mappings() before calling this function.  If
969   // 'other_lines' is non-NULL, fills that in with other line
970   // numbers assigned to the same offset.
971   std::string
972   addr2line(unsigned int shndx, off_t offset,
973             std::vector<std::string>* other_lines)
974   { return this->do_addr2line(shndx, offset, other_lines); }
975
976   // A helper function for a single addr2line lookup.  It also keeps a
977   // cache of the last CACHE_SIZE Dwarf_line_info objects it created;
978   // set to 0 not to cache at all.  The larger CACHE_SIZE is, the more
979   // chance this routine won't have to re-create a Dwarf_line_info
980   // object for its addr2line computation; such creations are slow.
981   // NOTE: Not thread-safe, so only call from one thread at a time.
982   static std::string
983   one_addr2line(Object* object, unsigned int shndx, off_t offset,
984                 size_t cache_size, std::vector<std::string>* other_lines);
985
986   // This reclaims all the memory that one_addr2line may have cached.
987   // Use this when you know you will not be calling one_addr2line again.
988   static void
989   clear_addr2line_cache();
990
991  private:
992   virtual std::string
993   do_addr2line(unsigned int shndx, off_t offset,
994                std::vector<std::string>* other_lines) = 0;
995 };
996
997 template<int size, bool big_endian>
998 class Sized_dwarf_line_info : public Dwarf_line_info
999 {
1000  public:
1001   // Initializes a .debug_line reader for a given object file.
1002   // If SHNDX is specified and non-negative, only read the debug
1003   // information that pertains to the specified section.
1004   Sized_dwarf_line_info(Object* object, unsigned int read_shndx = -1U);
1005
1006   virtual
1007   ~Sized_dwarf_line_info()
1008   {
1009     if (this->buffer_start_ != NULL)
1010       delete[] this->buffer_start_;
1011   }
1012
1013  private:
1014   std::string
1015   do_addr2line(unsigned int shndx, off_t offset,
1016                std::vector<std::string>* other_lines);
1017
1018   // Formats a file and line number to a string like "dirname/filename:lineno".
1019   std::string
1020   format_file_lineno(const Offset_to_lineno_entry& lineno) const;
1021
1022   // Start processing line info, and populates the offset_map_.
1023   // If SHNDX is non-negative, only store debug information that
1024   // pertains to the specified section.
1025   void
1026   read_line_mappings(unsigned int shndx);
1027
1028   // Reads the relocation section associated with .debug_line and
1029   // stores relocation information in reloc_map_.
1030   void
1031   read_relocs();
1032
1033   // Reads the DWARF2/3 header for this line info.  Each takes as input
1034   // a starting buffer position, and returns the ending position.
1035   const unsigned char*
1036   read_header_prolog(const unsigned char* lineptr);
1037
1038   const unsigned char*
1039   read_header_tables(const unsigned char* lineptr);
1040
1041   // Reads the DWARF2/3 line information.  If shndx is non-negative,
1042   // discard all line information that doesn't pertain to the given
1043   // section.
1044   const unsigned char*
1045   read_lines(const unsigned char* lineptr, unsigned int shndx);
1046
1047   // Process a single line info opcode at START using the state
1048   // machine at LSM.  Return true if we should define a line using the
1049   // current state of the line state machine.  Place the length of the
1050   // opcode in LEN.
1051   bool
1052   process_one_opcode(const unsigned char* start,
1053                      struct LineStateMachine* lsm, size_t* len);
1054
1055   // Some parts of processing differ depending on whether the input
1056   // was a .o file or not.
1057   bool input_is_relobj();
1058
1059   // If we saw anything amiss while parsing, we set this to false.
1060   // Then addr2line will always fail (rather than return possibly-
1061   // corrupt data).
1062   bool data_valid_;
1063
1064   // A DWARF2/3 line info header.  This is not the same size as in the
1065   // actual file, as the one in the file may have a 32 bit or 64 bit
1066   // lengths.
1067
1068   struct Dwarf_line_infoHeader
1069   {
1070     off_t total_length;
1071     int version;
1072     off_t prologue_length;
1073     int min_insn_length; // insn stands for instruction
1074     int max_ops_per_insn; // Added in DWARF-4.
1075     bool default_is_stmt; // stmt stands for statement
1076     signed char line_base;
1077     int line_range;
1078     unsigned char opcode_base;
1079     std::vector<unsigned char> std_opcode_lengths;
1080     int offset_size;
1081   } header_;
1082
1083   // buffer is the buffer for our line info, starting at exactly where
1084   // the line info to read is.
1085   const unsigned char* buffer_;
1086   const unsigned char* buffer_end_;
1087   // If the buffer was allocated temporarily, and therefore must be
1088   // deallocated in the dtor, this contains a pointer to the start
1089   // of the buffer.
1090   const unsigned char* buffer_start_;
1091
1092   // This has relocations that point into buffer.
1093   Sized_elf_reloc_mapper<size, big_endian>* reloc_mapper_;
1094   // The type of the reloc section in track_relocs_--SHT_REL or SHT_RELA.
1095   unsigned int track_relocs_type_;
1096
1097   // This is used to figure out what section to apply a relocation to.
1098   const unsigned char* symtab_buffer_;
1099   section_size_type symtab_buffer_size_;
1100
1101   // Holds the directories and files as we see them.  We have an array
1102   // of directory-lists, one for each .o file we're reading (usually
1103   // there will just be one, but there may be more if input is a .so).
1104   std::vector<std::vector<std::string> > directories_;
1105   // The first part is an index into directories_, the second the filename.
1106   std::vector<std::vector< std::pair<int, std::string> > > files_;
1107
1108   // An index into the current directories_ and files_ vectors.
1109   int current_header_index_;
1110
1111   // A sorted map from offset of the relocation target to the shndx
1112   // and addend for the relocation.
1113   typedef std::map<off_t, std::pair<unsigned int, off_t> >
1114   Reloc_map;
1115   Reloc_map reloc_map_;
1116
1117   // We have a vector of offset->lineno entries for every input section.
1118   typedef Unordered_map<unsigned int, std::vector<Offset_to_lineno_entry> >
1119   Lineno_map;
1120
1121   Lineno_map line_number_map_;
1122 };
1123
1124 } // End namespace gold.
1125
1126 #endif // !defined(GOLD_DWARF_READER_H)