gdb/dwarf2/abbrev.c

   1 /* DWARF 2 abbreviations
   2
   3    Copyright (C) 1994-2020 Free Software Foundation, Inc.
   4
   5    Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
   6    Inc.  with support from Florida State University (under contract
   7    with the Ada Joint Program Office), and Silicon Graphics, Inc.
   8    Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
   9    based on Fred Fish's (Cygnus Support) implementation of DWARF 1
  10    support.
  11
  12    This file is part of GDB.
  13
  14    This program is free software; you can redistribute it and/or modify
  15    it under the terms of the GNU General Public License as published by
  16    the Free Software Foundation; either version 3 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  26
  27 #include "defs.h"
  28 #include "dwarf2/read.h"
  29 #include "dwarf2/abbrev.h"
  30 #include "dwarf2/leb.h"
  31 #include "bfd.h"
  32
  33 /* Hash function for an abbrev.  */
  34
  35 static hashval_t
  36 hash_abbrev (const void *item)
  37 {
  38   const struct abbrev_info *info = (const struct abbrev_info *) item;
  39   /* Warning: if you change this next line, you must also update the
  40      other code in this class using the _with_hash functions.  */
  41   return info->number;
  42 }
  43
  44 /* Comparison function for abbrevs.  */
  45
  46 static int
  47 eq_abbrev (const void *lhs, const void *rhs)
  48 {
  49   const struct abbrev_info *l_info = (const struct abbrev_info *) lhs;
  50   const struct abbrev_info *r_info = (const struct abbrev_info *) rhs;
  51   return l_info->number == r_info->number;
  52 }
  53
  54 /* Abbreviation tables.
  55
  56    In DWARF version 2, the description of the debugging information is
  57    stored in a separate .debug_abbrev section.  Before we read any
  58    dies from a section we read in all abbreviations and install them
  59    in a hash table.  */
  60
  61 abbrev_table::abbrev_table (sect_offset off)
  62   : sect_off (off),
  63     m_abbrevs (htab_create_alloc (20, hash_abbrev, eq_abbrev,
  64                                   nullptr, xcalloc, xfree))
  65 {
  66 }
  67
  68 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE.  */
  69
  70 struct abbrev_info *
  71 abbrev_table::alloc_abbrev ()
  72 {
  73   struct abbrev_info *abbrev;
  74
  75   abbrev = XOBNEW (&m_abbrev_obstack, struct abbrev_info);
  76   memset (abbrev, 0, sizeof (struct abbrev_info));
  77
  78   return abbrev;
  79 }
  80
  81 /* Add an abbreviation to the table.  */
  82
  83 void
  84 abbrev_table::add_abbrev (struct abbrev_info *abbrev)
  85 {
  86   void **slot = htab_find_slot_with_hash (m_abbrevs.get (), abbrev,
  87                                           abbrev->number, INSERT);
  88   *slot = abbrev;
  89 }
  90
  91 /* Read in an abbrev table.  */
  92
  93 abbrev_table_up
  94 abbrev_table::read (struct objfile *objfile,
  95                     struct dwarf2_section_info *section,
  96                     sect_offset sect_off)
  97 {
  98   bfd *abfd = section->get_bfd_owner ();
  99   const gdb_byte *abbrev_ptr;
 100   struct abbrev_info *cur_abbrev;
 101   unsigned int abbrev_number, bytes_read, abbrev_name;
 102   unsigned int abbrev_form;
 103   std::vector<struct attr_abbrev> cur_attrs;
 104
 105   abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
 106
 107   section->read (objfile);
 108   abbrev_ptr = section->buffer + to_underlying (sect_off);
 109   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 110   abbrev_ptr += bytes_read;
 111
 112   /* Loop until we reach an abbrev number of 0.  */
 113   while (abbrev_number)
 114     {
 115       cur_attrs.clear ();
 116       cur_abbrev = abbrev_table->alloc_abbrev ();
 117
 118       /* read in abbrev header */
 119       cur_abbrev->number = abbrev_number;
 120       cur_abbrev->tag
 121         = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 122       abbrev_ptr += bytes_read;
 123       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
 124       abbrev_ptr += 1;
 125
 126       /* now read in declarations */
 127       for (;;)
 128         {
 129           LONGEST implicit_const;
 130
 131           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 132           abbrev_ptr += bytes_read;
 133           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 134           abbrev_ptr += bytes_read;
 135           if (abbrev_form == DW_FORM_implicit_const)
 136             {
 137               implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
 138                                                    &bytes_read);
 139               abbrev_ptr += bytes_read;
 140             }
 141           else
 142             {
 143               /* Initialize it due to a false compiler warning.  */
 144               implicit_const = -1;
 145             }
 146
 147           if (abbrev_name == 0)
 148             break;
 149
 150           cur_attrs.emplace_back ();
 151           struct attr_abbrev &cur_attr = cur_attrs.back ();
 152           cur_attr.name = (enum dwarf_attribute) abbrev_name;
 153           cur_attr.form = (enum dwarf_form) abbrev_form;
 154           cur_attr.implicit_const = implicit_const;
 155         }
 156
 157       cur_abbrev->num_attrs = cur_attrs.size ();
 158       cur_abbrev->attrs =
 159         XOBNEWVEC (&abbrev_table->m_abbrev_obstack, struct attr_abbrev,
 160                    cur_abbrev->num_attrs);
 161       if (!cur_attrs.empty ())
 162         memcpy (cur_abbrev->attrs, cur_attrs.data (),
 163                 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
 164
 165       abbrev_table->add_abbrev (cur_abbrev);
 166
 167       /* Get next abbreviation.
 168          Under Irix6 the abbreviations for a compilation unit are not
 169          always properly terminated with an abbrev number of 0.
 170          Exit loop if we encounter an abbreviation which we have
 171          already read (which means we are about to read the abbreviations
 172          for the next compile unit) or if the end of the abbreviation
 173          table is reached.  */
 174       if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
 175         break;
 176       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
 177       abbrev_ptr += bytes_read;
 178       if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
 179         break;
 180     }
 181
 182   return abbrev_table;
 183 }