gdb/psympriv.h

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