1// gdb-index.h -- generate .gdb_index section for fast debug lookup  -*- C++ -*-
2
3// Copyright (C) 2012-2017 Free Software Foundation, Inc.
4// Written by Cary Coutant <ccoutant@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#include <sys/types.h>
24#include <vector>
25
26#include "gold.h"
27#include "output.h"
28#include "mapfile.h"
29#include "stringpool.h"
30
31#ifndef GOLD_GDB_INDEX_H
32#define GOLD_GDB_INDEX_H
33
34namespace gold
35{
36
37class Output_section;
38class Output_file;
39class Mapfile;
40template<int size, bool big_endian>
41class Sized_relobj;
42class Dwarf_range_list;
43template <typename T>
44class Gdb_hashtab;
45class Gdb_index_info_reader;
46class Dwarf_pubnames_table;
47
48// This class manages the .gdb_index section, which is a fast
49// lookup table for DWARF information used by the gdb debugger.
50// The format of this section is described in gdb/doc/gdb.texinfo.
51
52class Gdb_index : public Output_section_data
53{
54 public:
55  Gdb_index(Output_section* gdb_index_section);
56
57  ~Gdb_index();
58
59  // Scan a .debug_info or .debug_types input section.
60  void scan_debug_info(bool is_type_unit,
61		       Relobj* object,
62		       const unsigned char* symbols,
63		       off_t symbols_size,
64		       unsigned int shndx,
65		       unsigned int reloc_shndx,
66		       unsigned int reloc_type);
67
68  // Add a compilation unit.
69  int
70  add_comp_unit(off_t cu_offset, off_t cu_length)
71  {
72    this->comp_units_.push_back(Comp_unit(cu_offset, cu_length));
73    return this->comp_units_.size() - 1;
74  }
75
76  // Add a type unit.
77  int
78  add_type_unit(off_t tu_offset, off_t type_offset, uint64_t signature)
79  {
80    this->type_units_.push_back(Type_unit(tu_offset, type_offset, signature));
81    return this->type_units_.size() - 1;
82  }
83
84  // Add an address range.
85  void
86  add_address_range_list(Relobj* object, unsigned int cu_index,
87			 Dwarf_range_list* ranges)
88  {
89    this->ranges_.push_back(Per_cu_range_list(object, cu_index, ranges));
90  }
91
92  // Add a symbol.  FLAGS are the gdb_index version 7 flags to be stored in
93  // the high-byte of the cu_index field.
94  void
95  add_symbol(int cu_index, const char* sym_name, uint8_t flags);
96
97  // Return the offset into the pubnames table for the cu at the given
98  // offset.
99  off_t
100  find_pubname_offset(off_t cu_offset);
101
102  // Return the offset into the pubtypes table for the cu at the
103  // given offset.
104  off_t
105  find_pubtype_offset(off_t cu_offset);
106
107  // Return TRUE if we have already processed the pubnames and types
108  // set for OBJECT of the CUs and TUS associated with the statement
109  // list at OFFSET.
110  bool
111  pubnames_read(const Relobj* object, off_t offset);
112
113  // Record that we have already read the pubnames associated with
114  // OBJECT and OFFSET.
115  void
116  set_pubnames_read(const Relobj* object, off_t offset);
117
118  // Return a pointer to the given table.
119  Dwarf_pubnames_table*
120  pubnames_table()
121  { return pubnames_table_; }
122
123  Dwarf_pubnames_table*
124  pubtypes_table()
125  { return pubtypes_table_; }
126
127  // Print usage statistics.
128  static void
129  print_stats();
130
131 protected:
132  // This is called to update the section size prior to assigning
133  // the address and file offset.
134  void
135  update_data_size()
136  { this->set_final_data_size(); }
137
138  // Set the final data size.
139  void
140  set_final_data_size();
141
142  // Write the data to the file.
143  void
144  do_write(Output_file*);
145
146  // Write to a map file.
147  void
148  do_print_to_mapfile(Mapfile* mapfile) const
149  { mapfile->print_output_data(this, _("** gdb_index")); }
150
151  // Create a map from dies to pubnames.
152  Dwarf_pubnames_table*
153  map_pubtable_to_dies(unsigned int attr,
154                       Gdb_index_info_reader* dwinfo,
155                       Relobj* object,
156                       const unsigned char* symbols,
157                       off_t symbols_size);
158
159  // Wrapper for map_pubtable_to_dies
160  void
161  map_pubnames_and_types_to_dies(Gdb_index_info_reader* dwinfo,
162                                 Relobj* object,
163                                 const unsigned char* symbols,
164                                 off_t symbols_size);
165
166 private:
167  // An entry in the compilation unit list.
168  struct Comp_unit
169  {
170    Comp_unit(off_t off, off_t len)
171      : cu_offset(off), cu_length(len)
172    { }
173    uint64_t cu_offset;
174    uint64_t cu_length;
175  };
176
177  // An entry in the type unit list.
178  struct Type_unit
179  {
180    Type_unit(off_t off, off_t toff, uint64_t sig)
181      : tu_offset(off), type_offset(toff), type_signature(sig)
182    { }
183    uint64_t tu_offset;
184    uint64_t type_offset;
185    uint64_t type_signature;
186  };
187
188  // An entry in the address range list.
189  struct Per_cu_range_list
190  {
191    Per_cu_range_list(Relobj* obj, uint32_t index, Dwarf_range_list* r)
192      : object(obj), cu_index(index), ranges(r)
193    { }
194    Relobj* object;
195    uint32_t cu_index;
196    Dwarf_range_list* ranges;
197  };
198
199  // A symbol table entry.
200  struct Gdb_symbol
201  {
202    Stringpool::Key name_key;
203    unsigned int hashval;
204    unsigned int cu_vector_index;
205
206    // Return the hash value.
207    unsigned int
208    hash()
209    { return this->hashval; }
210
211    // Return true if this symbol is the same as SYMBOL.
212    bool
213    equal(Gdb_symbol* symbol)
214    { return this->name_key == symbol->name_key; }
215  };
216
217  typedef std::vector<std::pair<int, uint8_t> > Cu_vector;
218
219  typedef Unordered_map<off_t, off_t> Pubname_offset_map;
220  Pubname_offset_map cu_pubname_map_;
221  Pubname_offset_map cu_pubtype_map_;
222
223  // Scan the given pubtable and build a map of the various dies it
224  // refers to, so we can process the entries when we encounter the
225  // die.
226  void
227  map_pubtable_to_dies(Dwarf_pubnames_table* table,
228                       Pubname_offset_map* map);
229
230  // Tables to store the pubnames section of the current object.
231  Dwarf_pubnames_table* pubnames_table_;
232  Dwarf_pubnames_table* pubtypes_table_;
233
234  // The .gdb_index section.
235  Output_section* gdb_index_section_;
236  // The list of DWARF compilation units.
237  std::vector<Comp_unit> comp_units_;
238  // The list of DWARF type units.
239  std::vector<Type_unit> type_units_;
240  // The list of address ranges.
241  std::vector<Per_cu_range_list> ranges_;
242  // The symbol table.
243  Gdb_hashtab<Gdb_symbol>* gdb_symtab_;
244  // The CU vector portion of the constant pool.
245  std::vector<Cu_vector*> cu_vector_list_;
246  // An array to map from a CU vector index to an offset to the constant pool.
247  off_t* cu_vector_offsets_;
248  // The string portion of the constant pool.
249  Stringpool stringpool_;
250  // Offsets of the various pieces of the .gdb_index section.
251  off_t tu_offset_;
252  off_t addr_offset_;
253  off_t symtab_offset_;
254  off_t cu_pool_offset_;
255  off_t stringpool_offset_;
256  // Object, stmt list offset of the CUs and TUs associated with the
257  // last read pubnames and pubtypes sections.
258  const Relobj* pubnames_object_;
259  off_t stmt_list_offset_;
260};
261
262} // End namespace gold.
263
264#endif // !defined(GOLD_GDB_INDEX_H)
265