Home | History | Annotate | Download | only in gold
      1 // gdb-index.cc -- generate .gdb_index section for fast debug lookup
      2 
      3 // Copyright (C) 2012-2014 Free Software Foundation, Inc.
      4 // Written by Cary Coutant <ccoutant (at) 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 "gold.h"
     24 
     25 #include "gdb-index.h"
     26 #include "dwarf_reader.h"
     27 #include "dwarf.h"
     28 #include "object.h"
     29 #include "output.h"
     30 #include "demangle.h"
     31 
     32 namespace gold
     33 {
     34 
     35 const int gdb_index_version = 7;
     36 
     37 // Sizes of various records in the .gdb_index section.
     38 const int gdb_index_offset_size = 4;
     39 const int gdb_index_hdr_size = 6 * gdb_index_offset_size;
     40 const int gdb_index_cu_size = 16;
     41 const int gdb_index_tu_size = 24;
     42 const int gdb_index_addr_size = 16 + gdb_index_offset_size;
     43 const int gdb_index_sym_size = 2 * gdb_index_offset_size;
     44 
     45 // This class manages the hashed symbol table for the .gdb_index section.
     46 // It is essentially equivalent to the hashtab implementation in libiberty,
     47 // but is copied into gdb sources and here for compatibility because its
     48 // data structure is exposed on disk.
     49 
     50 template <typename T>
     51 class Gdb_hashtab
     52 {
     53  public:
     54   Gdb_hashtab()
     55     : size_(0), capacity_(0), hashtab_(NULL)
     56   { }
     57 
     58   ~Gdb_hashtab()
     59   {
     60     for (size_t i = 0; i < this->capacity_; ++i)
     61       if (this->hashtab_[i] != NULL)
     62 	delete this->hashtab_[i];
     63     delete[] this->hashtab_;
     64   }
     65 
     66   // Add a symbol.
     67   T*
     68   add(T* symbol)
     69   {
     70     // Resize the hash table if necessary.
     71     if (4 * this->size_ / 3 >= this->capacity_)
     72       this->expand();
     73 
     74     T** slot = this->find_slot(symbol);
     75     if (*slot == NULL)
     76       {
     77 	++this->size_;
     78 	*slot = symbol;
     79       }
     80 
     81     return *slot;
     82   }
     83 
     84   // Return the current size.
     85   size_t
     86   size() const
     87   { return this->size_; }
     88 
     89   // Return the current capacity.
     90   size_t
     91   capacity() const
     92   { return this->capacity_; }
     93 
     94   // Return the contents of slot N.
     95   T*
     96   operator[](size_t n)
     97   { return this->hashtab_[n]; }
     98 
     99  private:
    100   // Find a symbol in the hash table, or return an empty slot if
    101   // the symbol is not in the table.
    102   T**
    103   find_slot(T* symbol)
    104   {
    105     unsigned int index = symbol->hash() & (this->capacity_ - 1);
    106     unsigned int step = ((symbol->hash() * 17) & (this->capacity_ - 1)) | 1;
    107 
    108     for (;;)
    109       {
    110 	if (this->hashtab_[index] == NULL
    111 	    || this->hashtab_[index]->equal(symbol))
    112 	  return &this->hashtab_[index];
    113 	index = (index + step) & (this->capacity_ - 1);
    114       }
    115   }
    116 
    117   // Expand the hash table.
    118   void
    119   expand()
    120   {
    121     if (this->capacity_ == 0)
    122       {
    123 	// Allocate the hash table for the first time.
    124 	this->capacity_ = Gdb_hashtab::initial_size;
    125 	this->hashtab_ = new T*[this->capacity_];
    126 	memset(this->hashtab_, 0, this->capacity_ * sizeof(T*));
    127       }
    128     else
    129       {
    130 	// Expand and rehash.
    131 	unsigned int old_cap = this->capacity_;
    132 	T** old_hashtab = this->hashtab_;
    133 	this->capacity_ *= 2;
    134 	this->hashtab_ = new T*[this->capacity_];
    135 	memset(this->hashtab_, 0, this->capacity_ * sizeof(T*));
    136 	for (size_t i = 0; i < old_cap; ++i)
    137 	  {
    138 	    if (old_hashtab[i] != NULL)
    139 	      {
    140 		T** slot = this->find_slot(old_hashtab[i]);
    141 		*slot = old_hashtab[i];
    142 	      }
    143 	  }
    144 	delete[] old_hashtab;
    145       }
    146   }
    147 
    148   // Initial size of the hash table; must be a power of 2.
    149   static const int initial_size = 1024;
    150   size_t size_;
    151   size_t capacity_;
    152   T** hashtab_;
    153 };
    154 
    155 // The hash function for strings in the mapped index.  This is copied
    156 // directly from gdb/dwarf2read.c.
    157 
    158 static unsigned int
    159 mapped_index_string_hash(const unsigned char* str)
    160 {
    161   unsigned int r = 0;
    162   unsigned char c;
    163 
    164   while ((c = *str++) != 0)
    165     {
    166       if (gdb_index_version >= 5)
    167 	c = tolower (c);
    168       r = r * 67 + c - 113;
    169     }
    170 
    171   return r;
    172 }
    173 
    174 // A specialization of Dwarf_info_reader, for building the .gdb_index.
    175 
    176 class Gdb_index_info_reader : public Dwarf_info_reader
    177 {
    178  public:
    179   Gdb_index_info_reader(bool is_type_unit,
    180 			Relobj* object,
    181 			const unsigned char* symbols,
    182 			off_t symbols_size,
    183 			unsigned int shndx,
    184 			unsigned int reloc_shndx,
    185 			unsigned int reloc_type,
    186 			Gdb_index* gdb_index)
    187     : Dwarf_info_reader(is_type_unit, object, symbols, symbols_size, shndx,
    188 			reloc_shndx, reloc_type),
    189       gdb_index_(gdb_index), cu_index_(0), cu_language_(0)
    190   { }
    191 
    192   ~Gdb_index_info_reader()
    193   { this->clear_declarations(); }
    194 
    195   // Print usage statistics.
    196   static void
    197   print_stats();
    198 
    199  protected:
    200   // Visit a compilation unit.
    201   virtual void
    202   visit_compilation_unit(off_t cu_offset, off_t cu_length, Dwarf_die*);
    203 
    204   // Visit a type unit.
    205   virtual void
    206   visit_type_unit(off_t tu_offset, off_t tu_length, off_t type_offset,
    207 		  uint64_t signature, Dwarf_die*);
    208 
    209  private:
    210   // A map for recording DIEs we've seen that may be referred to be
    211   // later DIEs (via DW_AT_specification or DW_AT_abstract_origin).
    212   // The map is indexed by a DIE offset within the compile unit.
    213   // PARENT_OFFSET_ is the offset of the DIE that represents the
    214   // outer context, and NAME_ is a pointer to a component of the
    215   // fully-qualified name.
    216   // Normally, the names we point to are in a string table, so we don't
    217   // have to manage them, but when we have a fully-qualified name
    218   // computed, we put it in the table, and set PARENT_OFFSET_ to -1
    219   // indicate a string that we are managing.
    220   struct Declaration_pair
    221   {
    222     Declaration_pair(off_t parent_offset, const char* name)
    223       : parent_offset_(parent_offset), name_(name)
    224     { }
    225 
    226     off_t parent_offset_;
    227     const char* name_;
    228   };
    229   typedef Unordered_map<off_t, Declaration_pair> Declaration_map;
    230 
    231   // Visit a top-level DIE.
    232   void
    233   visit_top_die(Dwarf_die* die);
    234 
    235   // Visit the children of a DIE.
    236   void
    237   visit_children(Dwarf_die* die, Dwarf_die* context);
    238 
    239   // Visit a DIE.
    240   void
    241   visit_die(Dwarf_die* die, Dwarf_die* context);
    242 
    243   // Visit the children of a DIE.
    244   void
    245   visit_children_for_decls(Dwarf_die* die);
    246 
    247   // Visit a DIE.
    248   void
    249   visit_die_for_decls(Dwarf_die* die, Dwarf_die* context);
    250 
    251   // Guess a fully-qualified name for a class type, based on member function
    252   // linkage names.
    253   std::string
    254   guess_full_class_name(Dwarf_die* die);
    255 
    256   // Add a declaration DIE to the table of declarations.
    257   void
    258   add_declaration(Dwarf_die* die, Dwarf_die* context);
    259 
    260   // Add a declaration whose fully-qualified name is already known.
    261   void
    262   add_declaration_with_full_name(Dwarf_die* die, const char* full_name);
    263 
    264   // Return the context for a DIE whose parent is at DIE_OFFSET.
    265   std::string
    266   get_context(off_t die_offset);
    267 
    268   // Construct a fully-qualified name for DIE.
    269   std::string
    270   get_qualified_name(Dwarf_die* die, Dwarf_die* context);
    271 
    272   // Record the address ranges for a compilation unit.
    273   void
    274   record_cu_ranges(Dwarf_die* die);
    275 
    276   // Wrapper for read_pubtable.
    277   bool
    278   read_pubnames_and_pubtypes(Dwarf_die* die);
    279 
    280   // Read the .debug_pubnames and .debug_pubtypes tables.
    281   bool
    282   read_pubtable(Dwarf_pubnames_table* table, off_t offset);
    283 
    284   // Clear the declarations map.
    285   void
    286   clear_declarations();
    287 
    288   // The Gdb_index section.
    289   Gdb_index* gdb_index_;
    290   // The current CU index (negative for a TU).
    291   int cu_index_;
    292   // The language of the current CU or TU.
    293   unsigned int cu_language_;
    294   // Map from DIE offset to (parent offset, name) pair,
    295   // for DW_AT_specification.
    296   Declaration_map declarations_;
    297 
    298   // Statistics.
    299   // Total number of DWARF compilation units processed.
    300   static unsigned int dwarf_cu_count;
    301   // Number of DWARF compilation units with pubnames/pubtypes.
    302   static unsigned int dwarf_cu_nopubnames_count;
    303   // Total number of DWARF type units processed.
    304   static unsigned int dwarf_tu_count;
    305   // Number of DWARF type units with pubnames/pubtypes.
    306   static unsigned int dwarf_tu_nopubnames_count;
    307 };
    308 
    309 // Total number of DWARF compilation units processed.
    310 unsigned int Gdb_index_info_reader::dwarf_cu_count = 0;
    311 // Number of DWARF compilation units without pubnames/pubtypes.
    312 unsigned int Gdb_index_info_reader::dwarf_cu_nopubnames_count = 0;
    313 // Total number of DWARF type units processed.
    314 unsigned int Gdb_index_info_reader::dwarf_tu_count = 0;
    315 // Number of DWARF type units without pubnames/pubtypes.
    316 unsigned int Gdb_index_info_reader::dwarf_tu_nopubnames_count = 0;
    317 
    318 // Process a compilation unit and parse its child DIE.
    319 
    320 void
    321 Gdb_index_info_reader::visit_compilation_unit(off_t cu_offset, off_t cu_length,
    322 					      Dwarf_die* root_die)
    323 {
    324   ++Gdb_index_info_reader::dwarf_cu_count;
    325   this->cu_index_ = this->gdb_index_->add_comp_unit(cu_offset, cu_length);
    326   this->visit_top_die(root_die);
    327 }
    328 
    329 // Process a type unit and parse its child DIE.
    330 
    331 void
    332 Gdb_index_info_reader::visit_type_unit(off_t tu_offset, off_t,
    333 				       off_t type_offset, uint64_t signature,
    334 				       Dwarf_die* root_die)
    335 {
    336   ++Gdb_index_info_reader::dwarf_tu_count;
    337   // Use a negative index to flag this as a TU instead of a CU.
    338   this->cu_index_ = -1 - this->gdb_index_->add_type_unit(tu_offset, type_offset,
    339 							 signature);
    340   this->visit_top_die(root_die);
    341 }
    342 
    343 // Process a top-level DIE.
    344 // For compile_unit DIEs, record the address ranges.  For all
    345 // interesting tags, add qualified names to the symbol table
    346 // and process interesting children.  We may need to process
    347 // certain children just for saving declarations that might be
    348 // referenced by later DIEs with a DW_AT_specification attribute.
    349 
    350 void
    351 Gdb_index_info_reader::visit_top_die(Dwarf_die* die)
    352 {
    353   this->clear_declarations();
    354 
    355   switch (die->tag())
    356     {
    357       case elfcpp::DW_TAG_compile_unit:
    358       case elfcpp::DW_TAG_type_unit:
    359 	this->cu_language_ = die->int_attribute(elfcpp::DW_AT_language);
    360 	if (die->tag() == elfcpp::DW_TAG_compile_unit)
    361 	  this->record_cu_ranges(die);
    362 	// If there is a pubnames and/or pubtypes section for this
    363 	// compilation unit, use those; otherwise, parse the DWARF
    364 	// info to extract the names.
    365 	if (!this->read_pubnames_and_pubtypes(die))
    366 	  {
    367 	    // Check for languages that require specialized knowledge to
    368 	    // construct fully-qualified names, that we don't yet support.
    369 	    if (this->cu_language_ == elfcpp::DW_LANG_Ada83
    370 		|| this->cu_language_ == elfcpp::DW_LANG_Fortran77
    371 		|| this->cu_language_ == elfcpp::DW_LANG_Fortran90
    372 		|| this->cu_language_ == elfcpp::DW_LANG_Java
    373 		|| this->cu_language_ == elfcpp::DW_LANG_Ada95
    374 		|| this->cu_language_ == elfcpp::DW_LANG_Fortran95
    375 		|| this->cu_language_ == elfcpp::DW_LANG_Fortran03
    376 		|| this->cu_language_ == elfcpp::DW_LANG_Fortran08)
    377 	      {
    378 		gold_warning(_("%s: --gdb-index currently supports "
    379 			       "only C and C++ languages"),
    380 			     this->object()->name().c_str());
    381 		return;
    382 	      }
    383 	    if (die->tag() == elfcpp::DW_TAG_compile_unit)
    384 	      ++Gdb_index_info_reader::dwarf_cu_nopubnames_count;
    385 	    else
    386 	      ++Gdb_index_info_reader::dwarf_tu_nopubnames_count;
    387 	    this->visit_children(die, NULL);
    388 	  }
    389 	break;
    390       default:
    391 	// The top level DIE should be one of the above.
    392 	gold_warning(_("%s: top level DIE is not DW_TAG_compile_unit "
    393 		       "or DW_TAG_type_unit"),
    394 		     this->object()->name().c_str());
    395 	return;
    396     }
    397 }
    398 
    399 // Visit the children of PARENT, looking for symbols to add to the index.
    400 // CONTEXT points to the DIE to use for constructing the qualified name --
    401 // NULL if PARENT is the top-level DIE; otherwise it is the same as PARENT.
    402 
    403 void
    404 Gdb_index_info_reader::visit_children(Dwarf_die* parent, Dwarf_die* context)
    405 {
    406   off_t next_offset = 0;
    407   for (off_t die_offset = parent->child_offset();
    408        die_offset != 0;
    409        die_offset = next_offset)
    410     {
    411       Dwarf_die die(this, die_offset, parent);
    412       if (die.tag() == 0)
    413 	break;
    414       this->visit_die(&die, context);
    415       next_offset = die.sibling_offset();
    416     }
    417 }
    418 
    419 // Visit a child DIE, looking for symbols to add to the index.
    420 // CONTEXT is the parent DIE, used for constructing the qualified name;
    421 // it is NULL if the parent DIE is the top-level DIE.
    422 
    423 void
    424 Gdb_index_info_reader::visit_die(Dwarf_die* die, Dwarf_die* context)
    425 {
    426   switch (die->tag())
    427     {
    428       case elfcpp::DW_TAG_subprogram:
    429       case elfcpp::DW_TAG_constant:
    430       case elfcpp::DW_TAG_variable:
    431       case elfcpp::DW_TAG_enumerator:
    432       case elfcpp::DW_TAG_base_type:
    433 	if (die->is_declaration())
    434 	  this->add_declaration(die, context);
    435 	else
    436 	  {
    437 	    // If the DIE is not a declaration, add it to the index.
    438 	    std::string full_name = this->get_qualified_name(die, context);
    439 	    if (!full_name.empty())
    440 	      this->gdb_index_->add_symbol(this->cu_index_,
    441                                            full_name.c_str(), 0);
    442 	  }
    443 	break;
    444       case elfcpp::DW_TAG_typedef:
    445       case elfcpp::DW_TAG_union_type:
    446       case elfcpp::DW_TAG_class_type:
    447       case elfcpp::DW_TAG_interface_type:
    448       case elfcpp::DW_TAG_structure_type:
    449       case elfcpp::DW_TAG_enumeration_type:
    450       case elfcpp::DW_TAG_subrange_type:
    451       case elfcpp::DW_TAG_namespace:
    452 	{
    453 	  std::string full_name;
    454 
    455 	  // For classes at the top level, we need to look for a
    456 	  // member function with a linkage name in order to get
    457 	  // the properly-canonicalized name.
    458 	  if (context == NULL
    459 	      && (die->tag() == elfcpp::DW_TAG_class_type
    460 		  || die->tag() == elfcpp::DW_TAG_structure_type
    461 		  || die->tag() == elfcpp::DW_TAG_union_type))
    462 	    full_name.assign(this->guess_full_class_name(die));
    463 
    464 	  // Because we will visit the children, we need to add this DIE
    465 	  // to the declarations table.
    466 	  if (full_name.empty())
    467 	    this->add_declaration(die, context);
    468 	  else
    469 	    this->add_declaration_with_full_name(die, full_name.c_str());
    470 
    471 	  // If the DIE is not a declaration, add it to the index.
    472 	  // Gdb stores a namespace in the index even when it is
    473 	  // a declaration.
    474 	  if (die->tag() == elfcpp::DW_TAG_namespace
    475 	      || !die->is_declaration())
    476 	    {
    477 	      if (full_name.empty())
    478 		full_name = this->get_qualified_name(die, context);
    479 	      if (!full_name.empty())
    480 		this->gdb_index_->add_symbol(this->cu_index_,
    481 					     full_name.c_str(), 0);
    482 	    }
    483 
    484 	  // We're interested in the children only for namespaces and
    485 	  // enumeration types.  For enumeration types, we do not include
    486 	  // the enumeration tag as part of the full name.  For other tags,
    487 	  // visit the children only to collect declarations.
    488 	  if (die->tag() == elfcpp::DW_TAG_namespace
    489 	      || die->tag() == elfcpp::DW_TAG_enumeration_type)
    490 	    this->visit_children(die, die);
    491 	  else
    492 	    this->visit_children_for_decls(die);
    493 	}
    494 	break;
    495       default:
    496 	break;
    497     }
    498 }
    499 
    500 // Visit the children of PARENT, looking only for declarations that
    501 // may be referenced by later specification DIEs.
    502 
    503 void
    504 Gdb_index_info_reader::visit_children_for_decls(Dwarf_die* parent)
    505 {
    506   off_t next_offset = 0;
    507   for (off_t die_offset = parent->child_offset();
    508        die_offset != 0;
    509        die_offset = next_offset)
    510     {
    511       Dwarf_die die(this, die_offset, parent);
    512       if (die.tag() == 0)
    513 	break;
    514       this->visit_die_for_decls(&die, parent);
    515       next_offset = die.sibling_offset();
    516     }
    517 }
    518 
    519 // Visit a child DIE, looking only for declarations that
    520 // may be referenced by later specification DIEs.
    521 
    522 void
    523 Gdb_index_info_reader::visit_die_for_decls(Dwarf_die* die, Dwarf_die* context)
    524 {
    525   switch (die->tag())
    526     {
    527       case elfcpp::DW_TAG_subprogram:
    528       case elfcpp::DW_TAG_constant:
    529       case elfcpp::DW_TAG_variable:
    530       case elfcpp::DW_TAG_enumerator:
    531       case elfcpp::DW_TAG_base_type:
    532 	{
    533 	  if (die->is_declaration())
    534 	    this->add_declaration(die, context);
    535 	}
    536 	break;
    537       case elfcpp::DW_TAG_typedef:
    538       case elfcpp::DW_TAG_union_type:
    539       case elfcpp::DW_TAG_class_type:
    540       case elfcpp::DW_TAG_interface_type:
    541       case elfcpp::DW_TAG_structure_type:
    542       case elfcpp::DW_TAG_enumeration_type:
    543       case elfcpp::DW_TAG_subrange_type:
    544       case elfcpp::DW_TAG_namespace:
    545 	{
    546 	  if (die->is_declaration())
    547 	    this->add_declaration(die, context);
    548 	  this->visit_children_for_decls(die);
    549 	}
    550 	break;
    551       default:
    552 	break;
    553     }
    554 }
    555 
    556 // Extract the class name from the linkage name of a member function.
    557 // This code is adapted from ../gdb/cp-support.c.
    558 
    559 #define d_left(dc) (dc)->u.s_binary.left
    560 #define d_right(dc) (dc)->u.s_binary.right
    561 
    562 static char*
    563 class_name_from_linkage_name(const char* linkage_name)
    564 {
    565   void* storage;
    566   struct demangle_component* tree =
    567       cplus_demangle_v3_components(linkage_name, DMGL_NO_OPTS, &storage);
    568   if (tree == NULL)
    569     return NULL;
    570 
    571   int done = 0;
    572 
    573   // First strip off any qualifiers, if we have a function or
    574   // method.
    575   while (!done)
    576     switch (tree->type)
    577       {
    578 	case DEMANGLE_COMPONENT_CONST:
    579 	case DEMANGLE_COMPONENT_RESTRICT:
    580 	case DEMANGLE_COMPONENT_VOLATILE:
    581 	case DEMANGLE_COMPONENT_CONST_THIS:
    582 	case DEMANGLE_COMPONENT_RESTRICT_THIS:
    583 	case DEMANGLE_COMPONENT_VOLATILE_THIS:
    584 	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
    585 	  tree = d_left(tree);
    586 	  break;
    587 	default:
    588 	  done = 1;
    589 	  break;
    590       }
    591 
    592   // If what we have now is a function, discard the argument list.
    593   if (tree->type == DEMANGLE_COMPONENT_TYPED_NAME)
    594     tree = d_left(tree);
    595 
    596   // If what we have now is a template, strip off the template
    597   // arguments.  The left subtree may be a qualified name.
    598   if (tree->type == DEMANGLE_COMPONENT_TEMPLATE)
    599     tree = d_left(tree);
    600 
    601   // What we have now should be a name, possibly qualified.
    602   // Additional qualifiers could live in the left subtree or the right
    603   // subtree.  Find the last piece.
    604   done = 0;
    605   struct demangle_component* prev_comp = NULL;
    606   struct demangle_component* cur_comp = tree;
    607   while (!done)
    608     switch (cur_comp->type)
    609       {
    610 	case DEMANGLE_COMPONENT_QUAL_NAME:
    611 	case DEMANGLE_COMPONENT_LOCAL_NAME:
    612 	  prev_comp = cur_comp;
    613 	  cur_comp = d_right(cur_comp);
    614 	  break;
    615 	case DEMANGLE_COMPONENT_TEMPLATE:
    616 	case DEMANGLE_COMPONENT_NAME:
    617 	case DEMANGLE_COMPONENT_CTOR:
    618 	case DEMANGLE_COMPONENT_DTOR:
    619 	case DEMANGLE_COMPONENT_OPERATOR:
    620 	case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
    621 	  done = 1;
    622 	  break;
    623 	default:
    624 	  done = 1;
    625 	  cur_comp = NULL;
    626 	  break;
    627       }
    628 
    629   char* ret = NULL;
    630   if (cur_comp != NULL && prev_comp != NULL)
    631     {
    632       // We want to discard the rightmost child of PREV_COMP.
    633       *prev_comp = *d_left(prev_comp);
    634       size_t allocated_size;
    635       ret = cplus_demangle_print(DMGL_NO_OPTS, tree, 30, &allocated_size);
    636     }
    637 
    638   free(storage);
    639   return ret;
    640 }
    641 
    642 // Guess a fully-qualified name for a class type, based on member function
    643 // linkage names.  This is needed for class/struct/union types at the
    644 // top level, because GCC does not always properly embed them within
    645 // the namespace.  As in gdb, we look for a member function with a linkage
    646 // name and extract the qualified name from the demangled name.
    647 
    648 std::string
    649 Gdb_index_info_reader::guess_full_class_name(Dwarf_die* die)
    650 {
    651   std::string full_name;
    652   off_t next_offset = 0;
    653 
    654   // This routine scans ahead in the DIE structure, possibly advancing
    655   // the relocation tracker beyond the current DIE.  We need to checkpoint
    656   // the tracker and reset it when we're done.
    657   uint64_t checkpoint = this->get_reloc_checkpoint();
    658 
    659   for (off_t child_offset = die->child_offset();
    660        child_offset != 0;
    661        child_offset = next_offset)
    662     {
    663       Dwarf_die child(this, child_offset, die);
    664       if (child.tag() == 0)
    665 	break;
    666       if (child.tag() == elfcpp::DW_TAG_subprogram)
    667         {
    668           const char* linkage_name = child.linkage_name();
    669 	  if (linkage_name != NULL)
    670 	    {
    671 	      char* guess = class_name_from_linkage_name(linkage_name);
    672 	      if (guess != NULL)
    673 	        {
    674 		  full_name.assign(guess);
    675 		  free(guess);
    676 		  break;
    677 	        }
    678 	    }
    679         }
    680       next_offset = child.sibling_offset();
    681     }
    682 
    683   this->reset_relocs(checkpoint);
    684   return full_name;
    685 }
    686 
    687 // Add a declaration DIE to the table of declarations.
    688 
    689 void
    690 Gdb_index_info_reader::add_declaration(Dwarf_die* die, Dwarf_die* context)
    691 {
    692   const char* name = die->name();
    693 
    694   off_t parent_offset = context != NULL ? context->offset() : 0;
    695 
    696   // If this DIE has a DW_AT_specification or DW_AT_abstract_origin
    697   // attribute, use the parent and name from the earlier declaration.
    698   off_t spec = die->specification();
    699   if (spec == 0)
    700     spec = die->abstract_origin();
    701   if (spec > 0)
    702     {
    703       Declaration_map::iterator it = this->declarations_.find(spec);
    704       if (it != this->declarations_.end())
    705         {
    706 	  parent_offset = it->second.parent_offset_;
    707 	  name = it->second.name_;
    708         }
    709     }
    710 
    711   if (name == NULL)
    712     {
    713       if (die->tag() == elfcpp::DW_TAG_namespace)
    714         name = "(anonymous namespace)";
    715       else if (die->tag() == elfcpp::DW_TAG_union_type)
    716         name = "(anonymous union)";
    717       else
    718         name = "(unknown)";
    719     }
    720 
    721   Declaration_pair decl(parent_offset, name);
    722   this->declarations_.insert(std::make_pair(die->offset(), decl));
    723 }
    724 
    725 // Add a declaration whose fully-qualified name is already known.
    726 // In the case where we had to get the canonical name by demangling
    727 // a linkage name, this ensures we use that name instead of the one
    728 // provided in DW_AT_name.
    729 
    730 void
    731 Gdb_index_info_reader::add_declaration_with_full_name(
    732     Dwarf_die* die,
    733     const char* full_name)
    734 {
    735   // We need to copy the name.
    736   int len = strlen(full_name);
    737   char* copy = new char[len + 1];
    738   memcpy(copy, full_name, len + 1);
    739 
    740   // Flag that we now manage the memory this points to.
    741   Declaration_pair decl(-1, copy);
    742   this->declarations_.insert(std::make_pair(die->offset(), decl));
    743 }
    744 
    745 // Return the context for a DIE whose parent is at DIE_OFFSET.
    746 
    747 std::string
    748 Gdb_index_info_reader::get_context(off_t die_offset)
    749 {
    750   std::string context;
    751   Declaration_map::iterator it = this->declarations_.find(die_offset);
    752   if (it != this->declarations_.end())
    753     {
    754       off_t parent_offset = it->second.parent_offset_;
    755       if (parent_offset > 0)
    756 	{
    757 	  context = get_context(parent_offset);
    758 	  context.append("::");
    759 	}
    760       if (it->second.name_ != NULL)
    761         context.append(it->second.name_);
    762     }
    763   return context;
    764 }
    765 
    766 // Construct the fully-qualified name for DIE.
    767 
    768 std::string
    769 Gdb_index_info_reader::get_qualified_name(Dwarf_die* die, Dwarf_die* context)
    770 {
    771   std::string full_name;
    772   const char* name = die->name();
    773 
    774   off_t parent_offset = context != NULL ? context->offset() : 0;
    775 
    776   // If this DIE has a DW_AT_specification or DW_AT_abstract_origin
    777   // attribute, use the parent and name from the earlier declaration.
    778   off_t spec = die->specification();
    779   if (spec == 0)
    780     spec = die->abstract_origin();
    781   if (spec > 0)
    782     {
    783       Declaration_map::iterator it = this->declarations_.find(spec);
    784       if (it != this->declarations_.end())
    785         {
    786 	  parent_offset = it->second.parent_offset_;
    787 	  name = it->second.name_;
    788         }
    789     }
    790 
    791   if (name == NULL && die->tag() == elfcpp::DW_TAG_namespace)
    792     name = "(anonymous namespace)";
    793   else if (name == NULL)
    794     return full_name;
    795 
    796   // If this is an enumerator constant, skip the immediate parent,
    797   // which is the enumeration tag.
    798   if (die->tag() == elfcpp::DW_TAG_enumerator)
    799     {
    800       Declaration_map::iterator it = this->declarations_.find(parent_offset);
    801       if (it != this->declarations_.end())
    802 	parent_offset = it->second.parent_offset_;
    803     }
    804 
    805   if (parent_offset > 0)
    806     {
    807       full_name.assign(this->get_context(parent_offset));
    808       full_name.append("::");
    809     }
    810   full_name.append(name);
    811 
    812   return full_name;
    813 }
    814 
    815 // Record the address ranges for a compilation unit.
    816 
    817 void
    818 Gdb_index_info_reader::record_cu_ranges(Dwarf_die* die)
    819 {
    820   unsigned int shndx;
    821   unsigned int shndx2;
    822 
    823   off_t ranges_offset = die->ref_attribute(elfcpp::DW_AT_ranges, &shndx);
    824   if (ranges_offset != -1)
    825     {
    826       Dwarf_range_list* ranges = this->read_range_list(shndx, ranges_offset);
    827       if (ranges != NULL)
    828 	this->gdb_index_->add_address_range_list(this->object(),
    829 						 this->cu_index_, ranges);
    830       return;
    831     }
    832 
    833   off_t low_pc = die->address_attribute(elfcpp::DW_AT_low_pc, &shndx);
    834   off_t high_pc = die->address_attribute(elfcpp::DW_AT_high_pc, &shndx2);
    835   if (high_pc == -1)
    836     {
    837       high_pc = die->uint_attribute(elfcpp::DW_AT_high_pc);
    838       high_pc += low_pc;
    839       shndx2 = shndx;
    840     }
    841   if ((low_pc != 0 || high_pc != 0) && low_pc != -1)
    842     {
    843       if (shndx != shndx2)
    844         {
    845 	  gold_warning(_("%s: DWARF info may be corrupt; low_pc and high_pc "
    846 			 "are in different sections"),
    847 		       this->object()->name().c_str());
    848 	  return;
    849 	}
    850       if (shndx == 0 || this->object()->is_section_included(shndx))
    851         {
    852 	  Dwarf_range_list* ranges = new Dwarf_range_list();
    853 	  ranges->add(shndx, low_pc, high_pc);
    854 	  this->gdb_index_->add_address_range_list(this->object(),
    855 						   this->cu_index_, ranges);
    856         }
    857     }
    858 }
    859 
    860 // Read table and add the relevant names to the index.  Returns true
    861 // if any names were added.
    862 
    863 bool
    864 Gdb_index_info_reader::read_pubtable(Dwarf_pubnames_table* table, off_t offset)
    865 {
    866   // If we couldn't read the section when building the cu_pubname_map,
    867   // then we won't find any pubnames now.
    868   if (table == NULL)
    869     return false;
    870 
    871   if (!table->read_header(offset))
    872     return false;
    873   while (true)
    874     {
    875       uint8_t flag_byte;
    876       const char* name = table->next_name(&flag_byte);
    877       if (name == NULL)
    878         break;
    879 
    880       this->gdb_index_->add_symbol(this->cu_index_, name, flag_byte);
    881     }
    882   return true;
    883 }
    884 
    885 // Read the .debug_pubnames and .debug_pubtypes tables for the CU or TU.
    886 // Returns TRUE if either a pubnames or pubtypes section was found.
    887 
    888 bool
    889 Gdb_index_info_reader::read_pubnames_and_pubtypes(Dwarf_die* die)
    890 {
    891   // If this is a skeleton debug-type die (generated via
    892   // -gsplit-dwarf), then the associated pubnames should have been
    893   // read along with the corresponding CU.  In any case, there isn't
    894   // enough info inside to build a gdb index entry.
    895   if (die->tag() == elfcpp::DW_TAG_type_unit
    896       && die->string_attribute(elfcpp::DW_AT_GNU_dwo_name))
    897     return true;
    898 
    899   // We use stmt_list_off as a unique identifier for the
    900   // compilation unit and its associated type units.
    901   unsigned int shndx;
    902   off_t stmt_list_off = die->ref_attribute (elfcpp::DW_AT_stmt_list,
    903                                             &shndx);
    904   // Look for the attr as either a flag or a ref.
    905   off_t offset = die->ref_attribute(elfcpp::DW_AT_GNU_pubnames, &shndx);
    906 
    907   // Newer versions of GCC generate CUs, but not TUs, with
    908   // DW_AT_FORM_flag_present.
    909   unsigned int flag = die->uint_attribute(elfcpp::DW_AT_GNU_pubnames);
    910   if (offset == -1 && flag == 0)
    911     {
    912       // Didn't find the attribute.
    913       if (die->tag() == elfcpp::DW_TAG_type_unit)
    914         {
    915           // If die is a TU, then it might correspond to a CU which we
    916           // have read. If it does, then no need to read the pubnames.
    917           // If it doesn't, then the caller will have to parse the
    918           // dies manually to find the names.
    919           return this->gdb_index_->pubnames_read(this->object(),
    920                                                  stmt_list_off);
    921         }
    922       else
    923         {
    924           // No attribute on the CU means that no pubnames were read.
    925           return false;
    926         }
    927     }
    928 
    929   // We found the attribute, so we can check if the corresponding
    930   // pubnames have been read.
    931   if (this->gdb_index_->pubnames_read(this->object(), stmt_list_off))
    932     return true;
    933 
    934   this->gdb_index_->set_pubnames_read(this->object(), stmt_list_off);
    935 
    936   // We have an attribute, and the pubnames haven't been read, so read
    937   // them.
    938   bool names = false;
    939   // In some of the cases, we could rely on the previous value of
    940   // offset here, but sorting out which cases complicates the logic
    941   // enough that it isn't worth it. So just look up the offset again.
    942   offset = this->gdb_index_->find_pubname_offset(this->cu_offset());
    943   names = this->read_pubtable(this->gdb_index_->pubnames_table(), offset);
    944 
    945   bool types = false;
    946   offset = this->gdb_index_->find_pubtype_offset(this->cu_offset());
    947   types = this->read_pubtable(this->gdb_index_->pubtypes_table(), offset);
    948   return names || types;
    949 }
    950 
    951 // Clear the declarations map.
    952 void
    953 Gdb_index_info_reader::clear_declarations()
    954 {
    955   // Free strings in memory we manage.
    956   for (Declaration_map::iterator it = this->declarations_.begin();
    957        it != this->declarations_.end();
    958        ++it)
    959     {
    960       if (it->second.parent_offset_ == -1)
    961 	delete[] it->second.name_;
    962     }
    963 
    964   this->declarations_.clear();
    965 }
    966 
    967 // Print usage statistics.
    968 void
    969 Gdb_index_info_reader::print_stats()
    970 {
    971   fprintf(stderr, _("%s: DWARF CUs: %u\n"),
    972           program_name, Gdb_index_info_reader::dwarf_cu_count);
    973   fprintf(stderr, _("%s: DWARF CUs without pubnames/pubtypes: %u\n"),
    974           program_name, Gdb_index_info_reader::dwarf_cu_nopubnames_count);
    975   fprintf(stderr, _("%s: DWARF TUs: %u\n"),
    976           program_name, Gdb_index_info_reader::dwarf_tu_count);
    977   fprintf(stderr, _("%s: DWARF TUs without pubnames/pubtypes: %u\n"),
    978           program_name, Gdb_index_info_reader::dwarf_tu_nopubnames_count);
    979 }
    980 
    981 // Class Gdb_index.
    982 
    983 // Construct the .gdb_index section.
    984 
    985 Gdb_index::Gdb_index(Output_section* gdb_index_section)
    986   : Output_section_data(4),
    987     pubnames_table_(NULL),
    988     pubtypes_table_(NULL),
    989     gdb_index_section_(gdb_index_section),
    990     comp_units_(),
    991     type_units_(),
    992     ranges_(),
    993     cu_vector_list_(),
    994     cu_vector_offsets_(NULL),
    995     stringpool_(),
    996     tu_offset_(0),
    997     addr_offset_(0),
    998     symtab_offset_(0),
    999     cu_pool_offset_(0),
   1000     stringpool_offset_(0),
   1001     pubnames_object_(NULL),
   1002     stmt_list_offset_(-1)
   1003 {
   1004   this->gdb_symtab_ = new Gdb_hashtab<Gdb_symbol>();
   1005 }
   1006 
   1007 Gdb_index::~Gdb_index()
   1008 {
   1009   // Free the memory used by the symbol table.
   1010   delete this->gdb_symtab_;
   1011   // Free the memory used by the CU vectors.
   1012   for (unsigned int i = 0; i < this->cu_vector_list_.size(); ++i)
   1013     delete this->cu_vector_list_[i];
   1014 }
   1015 
   1016 
   1017 // Scan the pubnames and pubtypes sections and build a map of the
   1018 // various cus and tus they refer to, so we can process the entries
   1019 // when we encounter the die for that cu or tu.
   1020 // Return the just-read table so it can be cached.
   1021 
   1022 Dwarf_pubnames_table*
   1023 Gdb_index::map_pubtable_to_dies(unsigned int attr,
   1024                                 Gdb_index_info_reader* dwinfo,
   1025                                 Relobj* object,
   1026                                 const unsigned char* symbols,
   1027                                 off_t symbols_size)
   1028 {
   1029   uint64_t section_offset = 0;
   1030   Dwarf_pubnames_table* table;
   1031   Pubname_offset_map* map;
   1032 
   1033   if (attr == elfcpp::DW_AT_GNU_pubnames)
   1034     {
   1035       table = new Dwarf_pubnames_table(dwinfo, false);
   1036       map = &this->cu_pubname_map_;
   1037     }
   1038   else
   1039     {
   1040       table = new Dwarf_pubnames_table(dwinfo, true);
   1041       map = &this->cu_pubtype_map_;
   1042     }
   1043 
   1044   map->clear();
   1045   if (!table->read_section(object, symbols, symbols_size))
   1046     return NULL;
   1047 
   1048   while (table->read_header(section_offset))
   1049     {
   1050       map->insert(std::make_pair(table->cu_offset(), section_offset));
   1051       section_offset += table->subsection_size();
   1052     }
   1053 
   1054   return table;
   1055 }
   1056 
   1057 // Wrapper for map_pubtable_to_dies
   1058 
   1059 void
   1060 Gdb_index::map_pubnames_and_types_to_dies(Gdb_index_info_reader* dwinfo,
   1061                                           Relobj* object,
   1062                                           const unsigned char* symbols,
   1063                                           off_t symbols_size)
   1064 {
   1065   // This is a new object, so reset the relevant variables.
   1066   this->pubnames_object_ = object;
   1067   this->stmt_list_offset_ = -1;
   1068 
   1069   delete this->pubnames_table_;
   1070   this->pubnames_table_
   1071       = this->map_pubtable_to_dies(elfcpp::DW_AT_GNU_pubnames, dwinfo,
   1072                                    object, symbols, symbols_size);
   1073   delete this->pubtypes_table_;
   1074   this->pubtypes_table_
   1075       = this->map_pubtable_to_dies(elfcpp::DW_AT_GNU_pubtypes, dwinfo,
   1076                                    object, symbols, symbols_size);
   1077 }
   1078 
   1079 // Given a cu_offset, find the associated section of the pubnames
   1080 // table.
   1081 
   1082 off_t
   1083 Gdb_index::find_pubname_offset(off_t cu_offset)
   1084 {
   1085   Pubname_offset_map::iterator it = this->cu_pubname_map_.find(cu_offset);
   1086   if (it != this->cu_pubname_map_.end())
   1087     return it->second;
   1088   return -1;
   1089 }
   1090 
   1091 // Given a cu_offset, find the associated section of the pubnames
   1092 // table.
   1093 
   1094 off_t
   1095 Gdb_index::find_pubtype_offset(off_t cu_offset)
   1096 {
   1097   Pubname_offset_map::iterator it = this->cu_pubtype_map_.find(cu_offset);
   1098   if (it != this->cu_pubtype_map_.end())
   1099     return it->second;
   1100   return -1;
   1101 }
   1102 
   1103 // Scan a .debug_info or .debug_types input section.
   1104 
   1105 void
   1106 Gdb_index::scan_debug_info(bool is_type_unit,
   1107 			   Relobj* object,
   1108 			   const unsigned char* symbols,
   1109 			   off_t symbols_size,
   1110 			   unsigned int shndx,
   1111 			   unsigned int reloc_shndx,
   1112 			   unsigned int reloc_type)
   1113 {
   1114   Gdb_index_info_reader dwinfo(is_type_unit, object,
   1115 			       symbols, symbols_size,
   1116 			       shndx, reloc_shndx,
   1117 			       reloc_type, this);
   1118   if (object != this->pubnames_object_)
   1119     map_pubnames_and_types_to_dies(&dwinfo, object, symbols, symbols_size);
   1120   dwinfo.parse();
   1121 }
   1122 
   1123 // Add a symbol.
   1124 
   1125 void
   1126 Gdb_index::add_symbol(int cu_index, const char* sym_name, uint8_t flags)
   1127 {
   1128   unsigned int hash = mapped_index_string_hash(
   1129       reinterpret_cast<const unsigned char*>(sym_name));
   1130   Gdb_symbol* sym = new Gdb_symbol();
   1131   this->stringpool_.add(sym_name, true, &sym->name_key);
   1132   sym->hashval = hash;
   1133   sym->cu_vector_index = 0;
   1134 
   1135   Gdb_symbol* found = this->gdb_symtab_->add(sym);
   1136   if (found == sym)
   1137     {
   1138       // New symbol -- allocate a new CU index vector.
   1139       found->cu_vector_index = this->cu_vector_list_.size();
   1140       this->cu_vector_list_.push_back(new Cu_vector());
   1141     }
   1142   else
   1143     {
   1144       // Found an existing symbol -- append to the existing
   1145       // CU index vector.
   1146       delete sym;
   1147     }
   1148 
   1149   // Add the CU index to the vector list for this symbol,
   1150   // if it's not already on the list.  We only need to
   1151   // check the last added entry.
   1152   Cu_vector* cu_vec = this->cu_vector_list_[found->cu_vector_index];
   1153   if (cu_vec->size() == 0
   1154       || cu_vec->back().first != cu_index
   1155       || cu_vec->back().second != flags)
   1156     cu_vec->push_back(std::make_pair(cu_index, flags));
   1157 }
   1158 
   1159 // Return TRUE if we have already processed the pubnames associated
   1160 // with the statement list at the given OFFSET.
   1161 
   1162 bool
   1163 Gdb_index::pubnames_read(const Relobj* object, off_t offset)
   1164 {
   1165   bool ret = (this->pubnames_object_ == object
   1166 	      && this->stmt_list_offset_ == offset);
   1167   return ret;
   1168 }
   1169 
   1170 // Record that we have processed the pubnames associated with the
   1171 // statement list for OBJECT at the given OFFSET.
   1172 
   1173 void
   1174 Gdb_index::set_pubnames_read(const Relobj* object, off_t offset)
   1175 {
   1176   this->pubnames_object_ = object;
   1177   this->stmt_list_offset_ = offset;
   1178 }
   1179 
   1180 // Set the size of the .gdb_index section.
   1181 
   1182 void
   1183 Gdb_index::set_final_data_size()
   1184 {
   1185   // Finalize the string pool.
   1186   this->stringpool_.set_string_offsets();
   1187 
   1188   // Compute the total size of the CU vectors.
   1189   // For each CU vector, include one entry for the count at the
   1190   // beginning of the vector.
   1191   unsigned int cu_vector_count = this->cu_vector_list_.size();
   1192   unsigned int cu_vector_size = 0;
   1193   this->cu_vector_offsets_ = new off_t[cu_vector_count];
   1194   for (unsigned int i = 0; i < cu_vector_count; ++i)
   1195     {
   1196       Cu_vector* cu_vec = this->cu_vector_list_[i];
   1197       cu_vector_offsets_[i] = cu_vector_size;
   1198       cu_vector_size += gdb_index_offset_size * (cu_vec->size() + 1);
   1199     }
   1200 
   1201   // Assign relative offsets to each portion of the index,
   1202   // and find the total size of the section.
   1203   section_size_type data_size = gdb_index_hdr_size;
   1204   data_size += this->comp_units_.size() * gdb_index_cu_size;
   1205   this->tu_offset_ = data_size;
   1206   data_size += this->type_units_.size() * gdb_index_tu_size;
   1207   this->addr_offset_ = data_size;
   1208   for (unsigned int i = 0; i < this->ranges_.size(); ++i)
   1209     data_size += this->ranges_[i].ranges->size() * gdb_index_addr_size;
   1210   this->symtab_offset_ = data_size;
   1211   data_size += this->gdb_symtab_->capacity() * gdb_index_sym_size;
   1212   this->cu_pool_offset_ = data_size;
   1213   data_size += cu_vector_size;
   1214   this->stringpool_offset_ = data_size;
   1215   data_size += this->stringpool_.get_strtab_size();
   1216 
   1217   this->set_data_size(data_size);
   1218 }
   1219 
   1220 // Write the data to the file.
   1221 
   1222 void
   1223 Gdb_index::do_write(Output_file* of)
   1224 {
   1225   const off_t off = this->offset();
   1226   const off_t oview_size = this->data_size();
   1227   unsigned char* const oview = of->get_output_view(off, oview_size);
   1228   unsigned char* pov = oview;
   1229 
   1230   // Write the file header.
   1231   // (1) Version number.
   1232   elfcpp::Swap<32, false>::writeval(pov, gdb_index_version);
   1233   pov += 4;
   1234   // (2) Offset of the CU list.
   1235   elfcpp::Swap<32, false>::writeval(pov, gdb_index_hdr_size);
   1236   pov += 4;
   1237   // (3) Offset of the types CU list.
   1238   elfcpp::Swap<32, false>::writeval(pov, this->tu_offset_);
   1239   pov += 4;
   1240   // (4) Offset of the address area.
   1241   elfcpp::Swap<32, false>::writeval(pov, this->addr_offset_);
   1242   pov += 4;
   1243   // (5) Offset of the symbol table.
   1244   elfcpp::Swap<32, false>::writeval(pov, this->symtab_offset_);
   1245   pov += 4;
   1246   // (6) Offset of the constant pool.
   1247   elfcpp::Swap<32, false>::writeval(pov, this->cu_pool_offset_);
   1248   pov += 4;
   1249 
   1250   gold_assert(pov - oview == gdb_index_hdr_size);
   1251 
   1252   // Write the CU list.
   1253   unsigned int comp_units_count = this->comp_units_.size();
   1254   for (unsigned int i = 0; i < comp_units_count; ++i)
   1255     {
   1256       const Comp_unit& cu = this->comp_units_[i];
   1257       elfcpp::Swap<64, false>::writeval(pov, cu.cu_offset);
   1258       elfcpp::Swap<64, false>::writeval(pov + 8, cu.cu_length);
   1259       pov += 16;
   1260     }
   1261 
   1262   gold_assert(pov - oview == this->tu_offset_);
   1263 
   1264   // Write the types CU list.
   1265   for (unsigned int i = 0; i < this->type_units_.size(); ++i)
   1266     {
   1267       const Type_unit& tu = this->type_units_[i];
   1268       elfcpp::Swap<64, false>::writeval(pov, tu.tu_offset);
   1269       elfcpp::Swap<64, false>::writeval(pov + 8, tu.type_offset);
   1270       elfcpp::Swap<64, false>::writeval(pov + 16, tu.type_signature);
   1271       pov += 24;
   1272     }
   1273 
   1274   gold_assert(pov - oview == this->addr_offset_);
   1275 
   1276   // Write the address area.
   1277   for (unsigned int i = 0; i < this->ranges_.size(); ++i)
   1278     {
   1279       int cu_index = this->ranges_[i].cu_index;
   1280       // Translate negative indexes, which refer to a TU, to a
   1281       // logical index into a concatenated CU/TU list.
   1282       if (cu_index < 0)
   1283         cu_index = comp_units_count + (-1 - cu_index);
   1284       Relobj* object = this->ranges_[i].object;
   1285       const Dwarf_range_list& ranges = *this->ranges_[i].ranges;
   1286       for (unsigned int j = 0; j < ranges.size(); ++j)
   1287         {
   1288 	  const Dwarf_range_list::Range& range = ranges[j];
   1289 	  uint64_t base = 0;
   1290 	  if (range.shndx > 0)
   1291 	    {
   1292 	      const Output_section* os = object->output_section(range.shndx);
   1293 	      base = (os->address()
   1294 		      + object->output_section_offset(range.shndx));
   1295 	    }
   1296 	  elfcpp::Swap_aligned32<64, false>::writeval(pov, base + range.start);
   1297 	  elfcpp::Swap_aligned32<64, false>::writeval(pov + 8,
   1298 						      base + range.end);
   1299 	  elfcpp::Swap<32, false>::writeval(pov + 16, cu_index);
   1300 	  pov += 20;
   1301 	}
   1302     }
   1303 
   1304   gold_assert(pov - oview == this->symtab_offset_);
   1305 
   1306   // Write the symbol table.
   1307   for (unsigned int i = 0; i < this->gdb_symtab_->capacity(); ++i)
   1308     {
   1309       const Gdb_symbol* sym = (*this->gdb_symtab_)[i];
   1310       section_offset_type name_offset = 0;
   1311       unsigned int cu_vector_offset = 0;
   1312       if (sym != NULL)
   1313 	{
   1314 	  name_offset = (this->stringpool_.get_offset_from_key(sym->name_key)
   1315 			 + this->stringpool_offset_ - this->cu_pool_offset_);
   1316 	  cu_vector_offset = this->cu_vector_offsets_[sym->cu_vector_index];
   1317 	}
   1318       elfcpp::Swap<32, false>::writeval(pov, name_offset);
   1319       elfcpp::Swap<32, false>::writeval(pov + 4, cu_vector_offset);
   1320       pov += 8;
   1321     }
   1322 
   1323   gold_assert(pov - oview == this->cu_pool_offset_);
   1324 
   1325   // Write the CU vectors into the constant pool.
   1326   for (unsigned int i = 0; i < this->cu_vector_list_.size(); ++i)
   1327     {
   1328       Cu_vector* cu_vec = this->cu_vector_list_[i];
   1329       elfcpp::Swap<32, false>::writeval(pov, cu_vec->size());
   1330       pov += 4;
   1331       for (unsigned int j = 0; j < cu_vec->size(); ++j)
   1332 	{
   1333 	  int cu_index = (*cu_vec)[j].first;
   1334           uint8_t flags = (*cu_vec)[j].second;
   1335 	  if (cu_index < 0)
   1336 	    cu_index = comp_units_count + (-1 - cu_index);
   1337           cu_index |= flags << 24;
   1338 	  elfcpp::Swap<32, false>::writeval(pov, cu_index);
   1339 	  pov += 4;
   1340 	}
   1341     }
   1342 
   1343   gold_assert(pov - oview == this->stringpool_offset_);
   1344 
   1345   // Write the strings into the constant pool.
   1346   this->stringpool_.write_to_buffer(pov, oview_size - this->stringpool_offset_);
   1347 
   1348   of->write_output_view(off, oview_size, oview);
   1349 }
   1350 
   1351 // Print usage statistics.
   1352 void
   1353 Gdb_index::print_stats()
   1354 {
   1355   if (parameters->options().gdb_index())
   1356     Gdb_index_info_reader::print_stats();
   1357 }
   1358 
   1359 } // End namespace gold.
   1360