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 + objfile->section_offsets[ginfo.section];
  59   }
  60
  61   /* Set the address of this partial symbol.  The address must be
  62      unrelocated.  */
  63   void set_unrelocated_address (CORE_ADDR addr)
  64   {
  65     ginfo.value.address = addr;
  66   }
  67
  68   /* Note that partial_symbol does not derive from general_symbol_info
  69      due to the bcache.  See add_psymbol_to_bcache.  */
  70
  71   struct general_symbol_info ginfo;
  72
  73   /* Name space code.  */
  74
  75   ENUM_BITFIELD(domain_enum_tag) domain : SYMBOL_DOMAIN_BITS;
  76
  77   /* Address class (for info_symbols).  Note that we don't allow
  78      synthetic "aclass" values here at present, simply because there's
  79      no need.  */
  80
  81   ENUM_BITFIELD(address_class) aclass : SYMBOL_ACLASS_BITS;
  82 };
  83
  84 /* A convenience enum to give names to some constants used when
  85    searching psymtabs.  This is internal to psymtab and should not be
  86    used elsewhere.  */
  87
  88 enum psymtab_search_status
  89   {
  90     PST_NOT_SEARCHED,
  91     PST_SEARCHED_AND_FOUND,
  92     PST_SEARCHED_AND_NOT_FOUND
  93   };
  94
  95 /* Each source file that has not been fully read in is represented by
  96    a partial_symtab.  This contains the information on where in the
  97    executable the debugging symbols for a specific file are, and a
  98    list of names of global symbols which are located in this file.
  99    They are all chained on partial symtab lists.
 100
 101    Even after the source file has been read into a symtab, the
 102    partial_symtab remains around.  They are allocated on an obstack,
 103    objfile_obstack.  */
 104
 105 struct partial_symtab
 106 {
 107   /* Allocate a new partial symbol table associated with OBJFILE.
 108      FILENAME (which must be non-NULL) is the filename of this partial
 109      symbol table; it is copied into the appropriate storage.  The
 110      partial symtab will also be installed using
 111      psymtab_storage::install.  */
 112
 113   partial_symtab (const char *filename, struct objfile *objfile)
 114     ATTRIBUTE_NONNULL (2) ATTRIBUTE_NONNULL (3);
 115
 116   /* Like the above, but also sets the initial text low and text high
 117      from the ADDR argument, and sets the global- and
 118      static-offsets.  */
 119
 120   partial_symtab (const char *filename, struct objfile *objfile,
 121                   CORE_ADDR addr)
 122     ATTRIBUTE_NONNULL (2) ATTRIBUTE_NONNULL (3);
 123
 124   virtual ~partial_symtab ()
 125   {
 126   }
 127
 128   /* Read the full symbol table corresponding to this partial symbol
 129      table.  */
 130   virtual void read_symtab (struct objfile *) = 0;
 131
 132   /* Psymtab expansion is done in two steps.  The first step is a call
 133      to read_symtab; but while that is in progress, calls to
 134      expand_psymtab can be made.  */
 135   virtual void expand_psymtab (struct objfile *) = 0;
 136
 137   /* Ensure that all the dependencies are read in.  */
 138   void read_dependencies (struct objfile *);
 139
 140   /* Return true if the symtab corresponding to this psymtab has been
 141      readin.  */
 142   virtual bool readin_p () const = 0;
 143
 144   /* Return a pointer to the compunit allocated for this source file.
 145      Return nullptr if !readin or if there was no symtab.  */
 146   virtual struct compunit_symtab *get_compunit_symtab () const = 0;
 147
 148
 149   /* Return the raw low text address of this partial_symtab.  */
 150   CORE_ADDR raw_text_low () const
 151   {
 152     return m_text_low;
 153   }
 154
 155   /* Return the raw high text address of this partial_symtab.  */
 156   CORE_ADDR raw_text_high () const
 157   {
 158     return m_text_high;
 159   }
 160
 161   /* Return the relocated low text address of this partial_symtab.  */
 162   CORE_ADDR text_low (struct objfile *objfile) const
 163   {
 164     return m_text_low + objfile->text_section_offset ();
 165   }
 166
 167   /* Return the relocated high text address of this partial_symtab.  */
 168   CORE_ADDR text_high (struct objfile *objfile) const
 169   {
 170     return m_text_high + objfile->text_section_offset ();
 171   }
 172
 173   /* Set the low text address of this partial_symtab.  */
 174   void set_text_low (CORE_ADDR addr)
 175   {
 176     m_text_low = addr;
 177     text_low_valid = 1;
 178   }
 179
 180   /* Set the hight text address of this partial_symtab.  */
 181   void set_text_high (CORE_ADDR addr)
 182   {
 183     m_text_high = addr;
 184     text_high_valid = 1;
 185   }
 186
 187
 188   /* Chain of all existing partial symtabs.  */
 189
 190   struct partial_symtab *next = nullptr;
 191
 192   /* Name of the source file which this partial_symtab defines,
 193      or if the psymtab is anonymous then a descriptive name for
 194      debugging purposes, or "".  It must not be NULL.  */
 195
 196   const char *filename = nullptr;
 197
 198   /* Full path of the source file.  NULL if not known.  */
 199
 200   char *fullname = nullptr;
 201
 202   /* Directory in which it was compiled, or NULL if we don't know.  */
 203
 204   const char *dirname = nullptr;
 205
 206   /* Range of text addresses covered by this file; texthigh is the
 207      beginning of the next section.  Do not use if PSYMTABS_ADDRMAP_SUPPORTED
 208      is set.  Do not refer directly to these fields.  Instead, use the
 209      accessors.  The validity of these fields is determined by the
 210      text_low_valid and text_high_valid fields; these are located later
 211      in this structure for better packing.  */
 212
 213   CORE_ADDR m_text_low = 0;
 214   CORE_ADDR m_text_high = 0;
 215
 216   /* If NULL, this is an ordinary partial symbol table.
 217
 218      If non-NULL, this holds a single includer of this partial symbol
 219      table, and this partial symbol table is a shared one.
 220
 221      A shared psymtab is one that is referenced by multiple other
 222      psymtabs, and which conceptually has its contents directly
 223      included in those.
 224
 225      Shared psymtabs have special semantics.  When a search finds a
 226      symbol in a shared table, we instead return one of the non-shared
 227      tables that include this one.
 228
 229      A shared psymtabs can be referred to by other shared ones.
 230
 231      The psymtabs that refer to a shared psymtab will list the shared
 232      psymtab in their 'dependencies' array.
 233
 234      In DWARF terms, a shared psymtab is a DW_TAG_partial_unit; but
 235      of course using a name based on that would be too confusing, so
 236      "shared" was chosen instead.
 237
 238      Only a single user is needed because, when expanding a shared
 239      psymtab, we only need to expand its "canonical" non-shared user.
 240      The choice of which one should be canonical is left to the
 241      debuginfo reader; it can be arbitrary.  */
 242
 243   struct partial_symtab *user = nullptr;
 244
 245   /* Array of pointers to all of the partial_symtab's which this one
 246      depends on.  Since this array can only be set to previous or
 247      the current (?) psymtab, this dependency tree is guaranteed not
 248      to have any loops.  "depends on" means that symbols must be read
 249      for the dependencies before being read for this psymtab; this is
 250      for type references in stabs, where if foo.c includes foo.h, declarations
 251      in foo.h may use type numbers defined in foo.c.  For other debugging
 252      formats there may be no need to use dependencies.  */
 253
 254   struct partial_symtab **dependencies = nullptr;
 255
 256   int number_of_dependencies = 0;
 257
 258   /* Global symbol list.  This list will be sorted after readin to
 259      improve access.  Binary search will be the usual method of
 260      finding a symbol within it.  globals_offset is an integer offset
 261      within global_psymbols[].  */
 262
 263   int globals_offset = 0;
 264   int n_global_syms = 0;
 265
 266   /* Static symbol list.  This list will *not* be sorted after readin;
 267      to find a symbol in it, exhaustive search must be used.  This is
 268      reasonable because searches through this list will eventually
 269      lead to either the read in of a files symbols for real (assumed
 270      to take a *lot* of time; check) or an error (and we don't care
 271      how long errors take).  This is an offset and size within
 272      static_psymbols[].  */
 273
 274   int statics_offset = 0;
 275   int n_static_syms = 0;
 276
 277   /* True iff objfile->psymtabs_addrmap is properly populated for this
 278      partial_symtab.  For discontiguous overlapping psymtabs is the only usable
 279      info in PSYMTABS_ADDRMAP.  */
 280
 281   bool psymtabs_addrmap_supported = false;
 282
 283   /* True if the name of this partial symtab is not a source file name.  */
 284
 285   bool anonymous = false;
 286
 287   /* A flag that is temporarily used when searching psymtabs.  */
 288
 289   ENUM_BITFIELD (psymtab_search_status) searched_flag : 2;
 290
 291   /* Validity of the m_text_low and m_text_high fields.  */
 292
 293   unsigned int text_low_valid : 1;
 294   unsigned int text_high_valid : 1;
 295 };
 296
 297 /* A partial symtab that tracks the "readin" and "compunit_symtab"
 298    information in the ordinary way -- by storing it directly in this
 299    object.  */
 300 struct standard_psymtab : public partial_symtab
 301 {
 302   standard_psymtab (const char *filename, struct objfile *objfile)
 303     : partial_symtab (filename, objfile)
 304   {
 305   }
 306
 307   standard_psymtab (const char *filename, struct objfile *objfile,
 308                     CORE_ADDR addr)
 309     : partial_symtab (filename, objfile, addr)
 310   {
 311   }
 312
 313   bool readin_p () const override
 314   {
 315     return readin;
 316   }
 317
 318   /* Return a pointer to the compunit allocated for this source file.
 319      Return nullptr if !readin or if there was no symtab.  */
 320   struct compunit_symtab *get_compunit_symtab () const override
 321   {
 322     return compunit_symtab;
 323   }
 324
 325   /* True if the symtab corresponding to this psymtab has been
 326      readin.  */
 327
 328   bool readin = false;
 329
 330   /* Pointer to compunit eventually allocated for this source file, 0 if
 331      !readin or if we haven't looked for the symtab after it was readin.  */
 332
 333   struct compunit_symtab *compunit_symtab = nullptr;
 334 };
 335
 336 /* A partial_symtab that works in the historical db way.  This should
 337    not be used in new code, but exists to transition the somewhat
 338    unmaintained "legacy" debug formats.  */
 339
 340 struct legacy_psymtab : public standard_psymtab
 341 {
 342   legacy_psymtab (const char *filename, struct objfile *objfile)
 343     : standard_psymtab (filename, objfile)
 344   {
 345   }
 346
 347   legacy_psymtab (const char *filename, struct objfile *objfile,
 348                   CORE_ADDR addr)
 349     : standard_psymtab (filename, objfile, addr)
 350   {
 351   }
 352
 353   void read_symtab (struct objfile *objf) override
 354   {
 355     if (legacy_read_symtab)
 356       (*legacy_read_symtab) (this, objf);
 357   }
 358
 359   void expand_psymtab (struct objfile *objf) override
 360   {
 361     (*legacy_expand_psymtab) (this, objf);
 362   }
 363
 364   /* Pointer to function which will read in the symtab corresponding to
 365      this psymtab.  */
 366
 367   void (*legacy_read_symtab) (legacy_psymtab *, struct objfile *) = nullptr;
 368
 369   /* Pointer to function which will actually expand this psymtab into
 370      a full symtab.  */
 371
 372   void (*legacy_expand_psymtab) (legacy_psymtab *, struct objfile *) = nullptr;
 373
 374   /* Information that lets read_symtab() locate the part of the symbol table
 375      that this psymtab corresponds to.  This information is private to the
 376      format-dependent symbol reading routines.  For further detail examine
 377      the various symbol reading modules.  */
 378
 379   void *read_symtab_private = nullptr;
 380 };
 381
 382 /* Specify whether a partial psymbol should be allocated on the global
 383    list or the static list.  */
 384
 385 enum class psymbol_placement
 386 {
 387   STATIC,
 388   GLOBAL
 389 };
 390
 391 /* Add a symbol to the partial symbol table of OBJFILE.
 392
 393    If COPY_NAME is true, make a copy of NAME, otherwise use the passed
 394    reference.
 395
 396    THECLASS is the type of symbol.
 397
 398    SECTION is the index of the section of OBJFILE in which the symbol is found.
 399
 400    WHERE determines whether the symbol goes in the list of static or global
 401    partial symbols of OBJFILE.
 402
 403    COREADDR is the address of the symbol.  For partial symbols that don't have
 404    an address, zero is passed.
 405
 406    LANGUAGE is the language from which the symbol originates.  This will
 407    influence, amongst other things, how the symbol name is demangled. */
 408
 409 extern void add_psymbol_to_list (gdb::string_view name,
 410                                  bool copy_name, domain_enum domain,
 411                                  enum address_class theclass,
 412                                  short section,
 413                                  psymbol_placement where,
 414                                  CORE_ADDR coreaddr,
 415                                  enum language language,
 416                                  struct objfile *objfile);
 417
 418 /* Initialize storage for partial symbols.  If partial symbol storage
 419    has already been initialized, this does nothing.  TOTAL_SYMBOLS is
 420    an estimate of how many symbols there will be.  */
 421
 422 extern void init_psymbol_list (struct objfile *objfile, int total_symbols);
 423
 424 extern void end_psymtab_common (struct objfile *, struct partial_symtab *);
 425
 426 static inline void
 427 discard_psymtab (struct objfile *objfile, struct partial_symtab *pst)
 428 {
 429   objfile->partial_symtabs->discard_psymtab (pst);
 430 }
 431
 432 /* Used when recording partial symbol tables.  On destruction,
 433    discards any partial symbol tables that have been built.  However,
 434    the tables can be kept by calling the "keep" method.  */
 435 class psymtab_discarder
 436 {
 437  public:
 438
 439   psymtab_discarder (struct objfile *objfile)
 440     : m_objfile (objfile),
 441       m_psymtab (objfile->partial_symtabs->psymtabs)
 442   {
 443   }
 444
 445   ~psymtab_discarder ()
 446   {
 447     if (m_objfile != NULL)
 448       m_objfile->partial_symtabs->discard_psymtabs_to (m_psymtab);
 449   }
 450
 451   /* Keep any partial symbol tables that were built.  */
 452   void keep ()
 453   {
 454     m_objfile = NULL;
 455   }
 456
 457  private:
 458
 459   /* The objfile.  If NULL this serves as a sentinel to indicate that
 460      the psymtabs should be kept.  */
 461   struct objfile *m_objfile;
 462   /* How far back to free.  */
 463   struct partial_symtab *m_psymtab;
 464 };
 465
 466 #endif /* PSYMPRIV_H */