gdb/psympriv.h

   1 /* Private partial symbol table definitions.
   2
   3    Copyright (C) 2009-2019 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef PSYMPRIV_H
  21 #define PSYMPRIV_H
  22
  23 #include "psymtab.h"
  24 #include "objfiles.h"
  25
  26 /* A partial_symbol records the name, domain, and address class of
  27    symbols whose types we have not parsed yet.  For functions, it also
  28    contains their memory address, so we can find them from a PC value.
  29    Each partial_symbol sits in a partial_symtab, all of which are chained
  30    on a  partial symtab list and which points to the corresponding
  31    normal symtab once the partial_symtab has been referenced.  */
  32
  33 /* This structure is space critical.  See space comments at the top of
  34    symtab.h.  */
  35
  36 struct partial_symbol : public general_symbol_info
  37 {
  38   /* Return the section for this partial symbol, or nullptr if no
  39      section has been set.  */
  40   struct obj_section *obj_section (struct objfile *objfile) const
  41   {
  42     if (section >= 0)
  43       return &objfile->sections[section];
  44     return nullptr;
  45   }
  46
  47   /* Return the unrelocated address of this partial symbol.  */
  48   CORE_ADDR unrelocated_address () const
  49   {
  50     return value.address;
  51   }
  52
  53   /* Return the address of this partial symbol, relocated according to
  54      the offsets provided in OBJFILE.  */
  55   CORE_ADDR address (const struct objfile *objfile) const
  56   {
  57     return value.address + ANOFFSET (objfile->section_offsets, section);
  58   }
  59
  60   /* Set the address of this partial symbol.  The address must be
  61      unrelocated.  */
  62   void set_unrelocated_address (CORE_ADDR addr)
  63   {
  64     value.address = addr;
  65   }
  66
  67   /* Name space code.  */
  68
  69   ENUM_BITFIELD(domain_enum_tag) domain : SYMBOL_DOMAIN_BITS;
  70
  71   /* Address class (for info_symbols).  Note that we don't allow
  72      synthetic "aclass" values here at present, simply because there's
  73      no need.  */
  74
  75   ENUM_BITFIELD(address_class) aclass : SYMBOL_ACLASS_BITS;
  76 };
  77
  78 /* A convenience enum to give names to some constants used when
  79    searching psymtabs.  This is internal to psymtab and should not be
  80    used elsewhere.  */
  81
  82 enum psymtab_search_status
  83   {
  84     PST_NOT_SEARCHED,
  85     PST_SEARCHED_AND_FOUND,
  86     PST_SEARCHED_AND_NOT_FOUND
  87   };
  88
  89 /* Each source file that has not been fully read in is represented by
  90    a partial_symtab.  This contains the information on where in the
  91    executable the debugging symbols for a specific file are, and a
  92    list of names of global symbols which are located in this file.
  93    They are all chained on partial symtab lists.
  94
  95    Even after the source file has been read into a symtab, the
  96    partial_symtab remains around.  They are allocated on an obstack,
  97    objfile_obstack.  */
  98
  99 struct partial_symtab
 100 {
 101   /* Return the raw low text address of this partial_symtab.  */
 102   CORE_ADDR raw_text_low () const
 103   {
 104     return m_text_low;
 105   }
 106
 107   /* Return the raw high text address of this partial_symtab.  */
 108   CORE_ADDR raw_text_high () const
 109   {
 110     return m_text_high;
 111   }
 112
 113   /* Return the relocated low text address of this partial_symtab.  */
 114   CORE_ADDR text_low (struct objfile *objfile) const
 115   {
 116     return m_text_low + ANOFFSET (objfile->section_offsets,
 117                                   SECT_OFF_TEXT (objfile));
 118   }
 119
 120   /* Return the relocated high text address of this partial_symtab.  */
 121   CORE_ADDR text_high (struct objfile *objfile) const
 122   {
 123     return m_text_high + ANOFFSET (objfile->section_offsets,
 124                                    SECT_OFF_TEXT (objfile));
 125   }
 126
 127   /* Set the low text address of this partial_symtab.  */
 128   void set_text_low (CORE_ADDR addr)
 129   {
 130     m_text_low = addr;
 131     text_low_valid = 1;
 132   }
 133
 134   /* Set the hight text address of this partial_symtab.  */
 135   void set_text_high (CORE_ADDR addr)
 136   {
 137     m_text_high = addr;
 138     text_high_valid = 1;
 139   }
 140
 141
 142   /* Chain of all existing partial symtabs.  */
 143
 144   struct partial_symtab *next;
 145
 146   /* Name of the source file which this partial_symtab defines,
 147      or if the psymtab is anonymous then a descriptive name for
 148      debugging purposes, or "".  It must not be NULL.  */
 149
 150   const char *filename;
 151
 152   /* Full path of the source file.  NULL if not known.  */
 153
 154   char *fullname;
 155
 156   /* Directory in which it was compiled, or NULL if we don't know.  */
 157
 158   const char *dirname;
 159
 160   /* Range of text addresses covered by this file; texthigh is the
 161      beginning of the next section.  Do not use if PSYMTABS_ADDRMAP_SUPPORTED
 162      is set.  Do not refer directly to these fields.  Instead, use the
 163      accessors.  The validity of these fields is determined by the
 164      text_low_valid and text_high_valid fields; these are located later
 165      in this structure for better packing.  */
 166
 167   CORE_ADDR m_text_low;
 168   CORE_ADDR m_text_high;
 169
 170   /* If NULL, this is an ordinary partial symbol table.
 171
 172      If non-NULL, this holds a single includer of this partial symbol
 173      table, and this partial symbol table is a shared one.
 174
 175      A shared psymtab is one that is referenced by multiple other
 176      psymtabs, and which conceptually has its contents directly
 177      included in those.
 178
 179      Shared psymtabs have special semantics.  When a search finds a
 180      symbol in a shared table, we instead return one of the non-shared
 181      tables that include this one.
 182
 183      A shared psymtabs can be referred to by other shared ones.
 184
 185      The psymtabs that refer to a shared psymtab will list the shared
 186      psymtab in their 'dependencies' array.
 187
 188      In DWARF terms, a shared psymtab is a DW_TAG_partial_unit; but
 189      of course using a name based on that would be too confusing, so
 190      "shared" was chosen instead.
 191
 192      Only a single user is needed because, when expanding a shared
 193      psymtab, we only need to expand its "canonical" non-shared user.
 194      The choice of which one should be canonical is left to the
 195      debuginfo reader; it can be arbitrary.  */
 196
 197   struct partial_symtab *user;
 198
 199   /* Array of pointers to all of the partial_symtab's which this one
 200      depends on.  Since this array can only be set to previous or
 201      the current (?) psymtab, this dependency tree is guaranteed not
 202      to have any loops.  "depends on" means that symbols must be read
 203      for the dependencies before being read for this psymtab; this is
 204      for type references in stabs, where if foo.c includes foo.h, declarations
 205      in foo.h may use type numbers defined in foo.c.  For other debugging
 206      formats there may be no need to use dependencies.  */
 207
 208   struct partial_symtab **dependencies;
 209
 210   int number_of_dependencies;
 211
 212   /* Global symbol list.  This list will be sorted after readin to
 213      improve access.  Binary search will be the usual method of
 214      finding a symbol within it.  globals_offset is an integer offset
 215      within global_psymbols[].  */
 216
 217   int globals_offset;
 218   int n_global_syms;
 219
 220   /* Static symbol list.  This list will *not* be sorted after readin;
 221      to find a symbol in it, exhaustive search must be used.  This is
 222      reasonable because searches through this list will eventually
 223      lead to either the read in of a files symbols for real (assumed
 224      to take a *lot* of time; check) or an error (and we don't care
 225      how long errors take).  This is an offset and size within
 226      static_psymbols[].  */
 227
 228   int statics_offset;
 229   int n_static_syms;
 230
 231   /* Non-zero if the symtab corresponding to this psymtab has been
 232      readin.  This is located here so that this structure packs better
 233      on 64-bit systems.  */
 234
 235   unsigned char readin;
 236
 237   /* True iff objfile->psymtabs_addrmap is properly populated for this
 238      partial_symtab.  For discontiguous overlapping psymtabs is the only usable
 239      info in PSYMTABS_ADDRMAP.  */
 240
 241   unsigned char psymtabs_addrmap_supported;
 242
 243   /* True if the name of this partial symtab is not a source file name.  */
 244
 245   unsigned char anonymous;
 246
 247   /* A flag that is temporarily used when searching psymtabs.  */
 248
 249   ENUM_BITFIELD (psymtab_search_status) searched_flag : 2;
 250
 251   /* Validity of the m_text_low and m_text_high fields.  */
 252
 253   unsigned int text_low_valid : 1;
 254   unsigned int text_high_valid : 1;
 255
 256   /* Pointer to compunit eventually allocated for this source file, 0 if
 257      !readin or if we haven't looked for the symtab after it was readin.  */
 258
 259   struct compunit_symtab *compunit_symtab;
 260
 261   /* Pointer to function which will read in the symtab corresponding to
 262      this psymtab.  */
 263
 264   void (*read_symtab) (struct partial_symtab *, struct objfile *);
 265
 266   /* Information that lets read_symtab() locate the part of the symbol table
 267      that this psymtab corresponds to.  This information is private to the
 268      format-dependent symbol reading routines.  For further detail examine
 269      the various symbol reading modules.  */
 270
 271   void *read_symtab_private;
 272 };
 273
 274 /* Specify whether a partial psymbol should be allocated on the global
 275    list or the static list.  */
 276
 277 enum class psymbol_placement
 278 {
 279   STATIC,
 280   GLOBAL
 281 };
 282
 283 /* Add any kind of symbol to a partial_symbol vector.  */
 284
 285 extern void add_psymbol_to_list (const char *, int,
 286                                  int, domain_enum,
 287                                  enum address_class,
 288                                  short /* section */,
 289                                  enum psymbol_placement,
 290                                  CORE_ADDR,
 291                                  enum language, struct objfile *);
 292
 293 /* Initialize storage for partial symbols.  If partial symbol storage
 294    has already been initialized, this does nothing.  TOTAL_SYMBOLS is
 295    an estimate of how many symbols there will be.  */
 296
 297 extern void init_psymbol_list (struct objfile *objfile, int total_symbols);
 298
 299 extern struct partial_symtab *start_psymtab_common (struct objfile *,
 300                                                     const char *, CORE_ADDR);
 301
 302 extern void end_psymtab_common (struct objfile *, struct partial_symtab *);
 303
 304 /* Allocate a new partial symbol table associated with OBJFILE.
 305    FILENAME (which must be non-NULL) is the filename of this partial
 306    symbol table; it is copied into the appropriate storage.  A new
 307    partial symbol table is returned; aside from "next" and "filename",
 308    its fields are initialized to zero.  */
 309
 310 extern struct partial_symtab *allocate_psymtab (const char *filename,
 311                                                 struct objfile *objfile)
 312   ATTRIBUTE_NONNULL (1);
 313
 314 static inline void
 315 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
 316 {
 317   objfile->partial_symtabs->discard_psymtab (pst);
 318 }
 319
 320 /* Used when recording partial symbol tables.  On destruction,
 321    discards any partial symbol tables that have been built.  However,
 322    the tables can be kept by calling the "keep" method.  */
 323 class psymtab_discarder
 324 {
 325  public:
 326
 327   psymtab_discarder (struct objfile *objfile)
 328     : m_objfile (objfile),
 329       m_psymtab (objfile->partial_symtabs->psymtabs)
 330   {
 331   }
 332
 333   ~psymtab_discarder ()
 334   {
 335     if (m_objfile != NULL)
 336       m_objfile->partial_symtabs->discard_psymtabs_to (m_psymtab);
 337   }
 338
 339   /* Keep any partial symbol tables that were built.  */
 340   void keep ()
 341   {
 342     m_objfile = NULL;
 343   }
 344
 345  private:
 346
 347   /* The objfile.  If NULL this serves as a sentinel to indicate that
 348      the psymtabs should be kept.  */
 349   struct objfile *m_objfile;
 350   /* How far back to free.  */
 351   struct partial_symtab *m_psymtab;
 352 };
 353
 354 #endif /* PSYMPRIV_H */