gdb/psympriv.h

   1 /* Private partial symbol table definitions.
   2
   3    Copyright (C) 2009-2018 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
  37 {
  38   /* The general symbol info required for all types of symbols.  */
  39
  40   struct general_symbol_info ginfo;
  41
  42   /* Name space code.  */
  43
  44   ENUM_BITFIELD(domain_enum_tag) domain : SYMBOL_DOMAIN_BITS;
  45
  46   /* Address class (for info_symbols).  Note that we don't allow
  47      synthetic "aclass" values here at present, simply because there's
  48      no need.  */
  49
  50   ENUM_BITFIELD(address_class) aclass : SYMBOL_ACLASS_BITS;
  51 };
  52
  53 #define PSYMBOL_DOMAIN(psymbol) (psymbol)->domain
  54 #define PSYMBOL_CLASS(psymbol)          (psymbol)->aclass
  55
  56 /* A convenience enum to give names to some constants used when
  57    searching psymtabs.  This is internal to psymtab and should not be
  58    used elsewhere.  */
  59
  60 enum psymtab_search_status
  61   {
  62     PST_NOT_SEARCHED,
  63     PST_SEARCHED_AND_FOUND,
  64     PST_SEARCHED_AND_NOT_FOUND
  65   };
  66
  67 /* Each source file that has not been fully read in is represented by
  68    a partial_symtab.  This contains the information on where in the
  69    executable the debugging symbols for a specific file are, and a
  70    list of names of global symbols which are located in this file.
  71    They are all chained on partial symtab lists.
  72
  73    Even after the source file has been read into a symtab, the
  74    partial_symtab remains around.  They are allocated on an obstack,
  75    objfile_obstack.  */
  76
  77 struct partial_symtab
  78 {
  79   /* Chain of all existing partial symtabs.  */
  80
  81   struct partial_symtab *next;
  82
  83   /* Name of the source file which this partial_symtab defines,
  84      or if the psymtab is anonymous then a descriptive name for
  85      debugging purposes, or "".  It must not be NULL.  */
  86
  87   const char *filename;
  88
  89   /* Full path of the source file.  NULL if not known.  */
  90
  91   char *fullname;
  92
  93   /* Directory in which it was compiled, or NULL if we don't know.  */
  94
  95   const char *dirname;
  96
  97   /* Range of text addresses covered by this file; texthigh is the
  98      beginning of the next section.  Do not use if PSYMTABS_ADDRMAP_SUPPORTED
  99      is set.  */
 100
 101   CORE_ADDR textlow;
 102   CORE_ADDR texthigh;
 103
 104   /* If NULL, this is an ordinary partial symbol table.
 105
 106      If non-NULL, this holds a single includer of this partial symbol
 107      table, and this partial symbol table is a shared one.
 108
 109      A shared psymtab is one that is referenced by multiple other
 110      psymtabs, and which conceptually has its contents directly
 111      included in those.
 112
 113      Shared psymtabs have special semantics.  When a search finds a
 114      symbol in a shared table, we instead return one of the non-shared
 115      tables that include this one.
 116
 117      A shared psymtabs can be referred to by other shared ones.
 118
 119      The psymtabs that refer to a shared psymtab will list the shared
 120      psymtab in their 'dependencies' array.
 121
 122      In DWARF terms, a shared psymtab is a DW_TAG_partial_unit; but
 123      of course using a name based on that would be too confusing, so
 124      "shared" was chosen instead.
 125
 126      Only a single user is needed because, when expanding a shared
 127      psymtab, we only need to expand its "canonical" non-shared user.
 128      The choice of which one should be canonical is left to the
 129      debuginfo reader; it can be arbitrary.  */
 130
 131   struct partial_symtab *user;
 132
 133   /* Array of pointers to all of the partial_symtab's which this one
 134      depends on.  Since this array can only be set to previous or
 135      the current (?) psymtab, this dependency tree is guaranteed not
 136      to have any loops.  "depends on" means that symbols must be read
 137      for the dependencies before being read for this psymtab; this is
 138      for type references in stabs, where if foo.c includes foo.h, declarations
 139      in foo.h may use type numbers defined in foo.c.  For other debugging
 140      formats there may be no need to use dependencies.  */
 141
 142   struct partial_symtab **dependencies;
 143
 144   int number_of_dependencies;
 145
 146   /* Global symbol list.  This list will be sorted after readin to
 147      improve access.  Binary search will be the usual method of
 148      finding a symbol within it.  globals_offset is an integer offset
 149      within global_psymbols[].  */
 150
 151   int globals_offset;
 152   int n_global_syms;
 153
 154   /* Static symbol list.  This list will *not* be sorted after readin;
 155      to find a symbol in it, exhaustive search must be used.  This is
 156      reasonable because searches through this list will eventually
 157      lead to either the read in of a files symbols for real (assumed
 158      to take a *lot* of time; check) or an error (and we don't care
 159      how long errors take).  This is an offset and size within
 160      static_psymbols[].  */
 161
 162   int statics_offset;
 163   int n_static_syms;
 164
 165   /* Non-zero if the symtab corresponding to this psymtab has been
 166      readin.  This is located here so that this structure packs better
 167      on 64-bit systems.  */
 168
 169   unsigned char readin;
 170
 171   /* True iff objfile->psymtabs_addrmap is properly populated for this
 172      partial_symtab.  For discontiguous overlapping psymtabs is the only usable
 173      info in PSYMTABS_ADDRMAP.  */
 174
 175   unsigned char psymtabs_addrmap_supported;
 176
 177   /* True if the name of this partial symtab is not a source file name.  */
 178
 179   unsigned char anonymous;
 180
 181   /* A flag that is temporarily used when searching psymtabs.  */
 182
 183   ENUM_BITFIELD (psymtab_search_status) searched_flag : 2;
 184
 185   /* Pointer to compunit eventually allocated for this source file, 0 if
 186      !readin or if we haven't looked for the symtab after it was readin.  */
 187
 188   struct compunit_symtab *compunit_symtab;
 189
 190   /* Pointer to function which will read in the symtab corresponding to
 191      this psymtab.  */
 192
 193   void (*read_symtab) (struct partial_symtab *, struct objfile *);
 194
 195   /* Information that lets read_symtab() locate the part of the symbol table
 196      that this psymtab corresponds to.  This information is private to the
 197      format-dependent symbol reading routines.  For further detail examine
 198      the various symbol reading modules.  */
 199
 200   void *read_symtab_private;
 201 };
 202
 203 /* Add any kind of symbol to a partial_symbol vector.  */
 204
 205 extern void add_psymbol_to_list (const char *, int,
 206                                  int, domain_enum,
 207                                  enum address_class,
 208                                  std::vector<partial_symbol *> *,
 209                                  CORE_ADDR,
 210                                  enum language, struct objfile *);
 211
 212 extern void init_psymbol_list (struct objfile *, int);
 213
 214 extern struct partial_symtab *start_psymtab_common (struct objfile *,
 215                                                     const char *, CORE_ADDR,
 216                                                     std::vector<partial_symbol *> &,
 217                                                     std::vector<partial_symbol *> &);
 218
 219 extern void end_psymtab_common (struct objfile *, struct partial_symtab *);
 220
 221 extern struct partial_symtab *allocate_psymtab (const char *,
 222                                                 struct objfile *)
 223   ATTRIBUTE_NONNULL (1);
 224
 225 extern void discard_psymtab (struct objfile *, struct partial_symtab *);
 226
 227 /* Used when recording partial symbol tables.  On destruction,
 228    discards any partial symbol tables that have been built.  However,
 229    the tables can be kept by calling the "keep" method.  */
 230 class psymtab_discarder
 231 {
 232  public:
 233
 234   psymtab_discarder (struct objfile *objfile)
 235     : m_objfile (objfile),
 236       m_psymtab (objfile->psymtabs)
 237   {
 238   }
 239
 240   ~psymtab_discarder ()
 241   {
 242     if (m_objfile != NULL)
 243       while (m_objfile->psymtabs != m_psymtab)
 244         discard_psymtab (m_objfile, m_objfile->psymtabs);
 245   }
 246
 247   /* Keep any partial symbol tables that were built.  */
 248   void keep ()
 249   {
 250     m_objfile = NULL;
 251   }
 252
 253  private:
 254
 255   /* The objfile.  If NULL this serves as a sentinel to indicate that
 256      the psymtabs should be kept.  */
 257   struct objfile *m_objfile;
 258   /* How far back to free.  */
 259   struct partial_symtab *m_psymtab;
 260 };
 261
 262 /* Traverse all psymtabs in one objfile.  */
 263
 264 #define ALL_OBJFILE_PSYMTABS(objfile, p) \
 265     for ((p) = (objfile) -> psymtabs; (p) != NULL; (p) = (p) -> next)
 266
 267 #endif /* PSYMPRIV_H */