gdb/buildsym.h

   1 /* Build symbol tables in GDB's internal format.
   2    Copyright (C) 1986-2019 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #if !defined (BUILDSYM_H)
  20 #define BUILDSYM_H 1
  21
  22 struct objfile;
  23 struct symbol;
  24 struct addrmap;
  25 struct compunit_symtab;
  26 enum language;
  27
  28 /* This module provides definitions used for creating and adding to
  29    the symbol table.  These routines are called from various symbol-
  30    file-reading routines.
  31
  32    They originated in dbxread.c of gdb-4.2, and were split out to
  33    make xcoffread.c more maintainable by sharing code.  */
  34
  35 struct block;
  36 struct pending_block;
  37
  38 struct dynamic_prop;
  39
  40 /* The list of sub-source-files within the current individual
  41    compilation.  Each file gets its own symtab with its own linetable
  42    and associated info, but they all share one blockvector.  */
  43
  44 struct subfile
  45 {
  46   struct subfile *next;
  47   /* Space for this is malloc'd.  */
  48   char *name;
  49   /* Space for this is malloc'd.  */
  50   struct linetable *line_vector;
  51   int line_vector_length;
  52   /* The "containing" compunit.  */
  53   struct buildsym_compunit *buildsym_compunit;
  54   enum language language;
  55   struct symtab *symtab;
  56 };
  57
  58 /* Record the symbols defined for each context in a list.  We don't
  59    create a struct block for the context until we know how long to
  60    make it.  */
  61
  62 #define PENDINGSIZE 100
  63
  64 struct pending
  65   {
  66     struct pending *next;
  67     int nsyms;
  68     struct symbol *symbol[PENDINGSIZE];
  69   };
  70
  71 /* Stack representing unclosed lexical contexts (that will become
  72    blocks, eventually).  */
  73
  74 struct context_stack
  75   {
  76     /* Outer locals at the time we entered */
  77
  78     struct pending *locals;
  79
  80     /* Pending using directives at the time we entered.  */
  81
  82     struct using_direct *local_using_directives;
  83
  84     /* Pointer into blocklist as of entry */
  85
  86     struct pending_block *old_blocks;
  87
  88     /* Name of function, if any, defining context */
  89
  90     struct symbol *name;
  91
  92     /* Expression that computes the frame base of the lexically enclosing
  93        function, if any.  NULL otherwise.  */
  94
  95     struct dynamic_prop *static_link;
  96
  97     /* PC where this context starts */
  98
  99     CORE_ADDR start_addr;
 100
 101     /* Temp slot for exception handling.  */
 102
 103     CORE_ADDR end_addr;
 104
 105     /* For error-checking matching push/pop */
 106
 107     int depth;
 108
 109   };
 110
 111 /* Buildsym's counterpart to struct compunit_symtab.  */
 112
 113 struct buildsym_compunit
 114 {
 115   /* Start recording information about a primary source file (IOW, not an
 116      included source file).
 117      COMP_DIR is the directory in which the compilation unit was compiled
 118      (or NULL if not known).  */
 119
 120   buildsym_compunit (struct objfile *objfile_, const char *name,
 121                      const char *comp_dir_, enum language language_,
 122                      CORE_ADDR last_addr);
 123
 124   /* Reopen an existing compunit_symtab so that additional symbols can
 125      be added to it.  Arguments are as for the main constructor.  CUST
 126      is the expandable compunit_symtab to be reopened.  */
 127
 128   buildsym_compunit (struct objfile *objfile_, const char *name,
 129                      const char *comp_dir_, enum language language_,
 130                      CORE_ADDR last_addr, struct compunit_symtab *cust)
 131     : m_objfile (objfile_),
 132       m_last_source_file (name == nullptr ? nullptr : xstrdup (name)),
 133       m_comp_dir (comp_dir_ == nullptr ? nullptr : xstrdup (comp_dir_)),
 134       m_compunit_symtab (cust),
 135       m_language (language_),
 136       m_last_source_start_addr (last_addr)
 137   {
 138   }
 139
 140   ~buildsym_compunit ();
 141
 142   DISABLE_COPY_AND_ASSIGN (buildsym_compunit);
 143
 144   void set_last_source_file (const char *name)
 145   {
 146     char *new_name = name == NULL ? NULL : xstrdup (name);
 147     m_last_source_file.reset (new_name);
 148   }
 149
 150   const char *get_last_source_file ()
 151   {
 152     return m_last_source_file.get ();
 153   }
 154
 155   struct macro_table *get_macro_table ();
 156
 157   struct macro_table *release_macros ()
 158   {
 159     struct macro_table *result = m_pending_macros;
 160     m_pending_macros = nullptr;
 161     return result;
 162   }
 163
 164   /* This function is called to discard any pending blocks.  */
 165
 166   void free_pending_blocks ()
 167   {
 168     m_pending_block_obstack.clear ();
 169     m_pending_blocks = nullptr;
 170   }
 171
 172   struct block *finish_block (struct symbol *symbol,
 173                               struct pending_block *old_blocks,
 174                               const struct dynamic_prop *static_link,
 175                               CORE_ADDR start, CORE_ADDR end);
 176
 177   void record_block_range (struct block *block,
 178                            CORE_ADDR start, CORE_ADDR end_inclusive);
 179
 180   void start_subfile (const char *name);
 181
 182   void patch_subfile_names (struct subfile *subfile, const char *name);
 183
 184   void push_subfile ();
 185
 186   const char *pop_subfile ();
 187
 188   void record_line (struct subfile *subfile, int line, CORE_ADDR pc);
 189
 190   struct compunit_symtab *get_compunit_symtab ()
 191   {
 192     return m_compunit_symtab;
 193   }
 194
 195   void set_last_source_start_addr (CORE_ADDR addr)
 196   {
 197     m_last_source_start_addr = addr;
 198   }
 199
 200   CORE_ADDR get_last_source_start_addr ()
 201   {
 202     return m_last_source_start_addr;
 203   }
 204
 205   struct using_direct **get_local_using_directives ()
 206   {
 207     return &m_local_using_directives;
 208   }
 209
 210   void set_local_using_directives (struct using_direct *new_local)
 211   {
 212     m_local_using_directives = new_local;
 213   }
 214
 215   struct using_direct **get_global_using_directives ()
 216   {
 217     return &m_global_using_directives;
 218   }
 219
 220   bool outermost_context_p () const
 221   {
 222     return m_context_stack.empty ();
 223   }
 224
 225   struct context_stack *get_current_context_stack ()
 226   {
 227     if (m_context_stack.empty ())
 228       return nullptr;
 229     return &m_context_stack.back ();
 230   }
 231
 232   int get_context_stack_depth () const
 233   {
 234     return m_context_stack.size ();
 235   }
 236
 237   struct subfile *get_current_subfile ()
 238   {
 239     return m_current_subfile;
 240   }
 241
 242   struct pending **get_local_symbols ()
 243   {
 244     return &m_local_symbols;
 245   }
 246
 247   struct pending **get_file_symbols ()
 248   {
 249     return &m_file_symbols;
 250   }
 251
 252   struct pending **get_global_symbols ()
 253   {
 254     return &m_global_symbols;
 255   }
 256
 257   void record_debugformat (const char *format)
 258   {
 259     m_debugformat = format;
 260   }
 261
 262   void record_producer (const char *producer)
 263   {
 264     m_producer = producer;
 265   }
 266
 267   struct context_stack *push_context (int desc, CORE_ADDR valu);
 268
 269   struct context_stack pop_context ();
 270
 271   struct block *end_symtab_get_static_block (CORE_ADDR end_addr,
 272                                              int expandable, int required);
 273
 274   struct compunit_symtab *end_symtab_from_static_block
 275       (struct block *static_block, int section, int expandable);
 276
 277   struct compunit_symtab *end_symtab (CORE_ADDR end_addr, int section);
 278
 279   struct compunit_symtab *end_expandable_symtab (CORE_ADDR end_addr,
 280                                                  int section);
 281
 282   void augment_type_symtab ();
 283
 284 private:
 285
 286   void record_pending_block (struct block *block, struct pending_block *opblock);
 287
 288   struct block *finish_block_internal (struct symbol *symbol,
 289                                        struct pending **listhead,
 290                                        struct pending_block *old_blocks,
 291                                        const struct dynamic_prop *static_link,
 292                                        CORE_ADDR start, CORE_ADDR end,
 293                                        int is_global, int expandable);
 294
 295   struct blockvector *make_blockvector ();
 296
 297   void watch_main_source_file_lossage ();
 298
 299   struct compunit_symtab *end_symtab_with_blockvector
 300       (struct block *static_block, int section, int expandable);
 301
 302   /* The objfile we're reading debug info from.  */
 303   struct objfile *m_objfile;
 304
 305   /* List of subfiles (source files).
 306      Files are added to the front of the list.
 307      This is important mostly for the language determination hacks we use,
 308      which iterate over previously added files.  */
 309   struct subfile *m_subfiles = nullptr;
 310
 311   /* The subfile of the main source file.  */
 312   struct subfile *m_main_subfile = nullptr;
 313
 314   /* Name of source file whose symbol data we are now processing.  This
 315      comes from a symbol of type N_SO for stabs.  For DWARF it comes
 316      from the DW_AT_name attribute of a DW_TAG_compile_unit DIE.  */
 317   gdb::unique_xmalloc_ptr<char> m_last_source_file;
 318
 319   /* E.g., DW_AT_comp_dir if DWARF.  Space for this is malloc'd.  */
 320   gdb::unique_xmalloc_ptr<char> m_comp_dir;
 321
 322   /* Space for this is not malloc'd, and is assumed to have at least
 323      the same lifetime as objfile.  */
 324   const char *m_producer = nullptr;
 325
 326   /* Space for this is not malloc'd, and is assumed to have at least
 327      the same lifetime as objfile.  */
 328   const char *m_debugformat = nullptr;
 329
 330   /* The compunit we are building.  */
 331   struct compunit_symtab *m_compunit_symtab = nullptr;
 332
 333   /* Language of this compunit_symtab.  */
 334   enum language m_language;
 335
 336   /* The macro table for the compilation unit whose symbols we're
 337      currently reading.  */
 338   struct macro_table *m_pending_macros = nullptr;
 339
 340   /* True if symtab has line number info.  This prevents an otherwise
 341      empty symtab from being tossed.  */
 342   bool m_have_line_numbers = false;
 343
 344   /* Core address of start of text of current source file.  This too
 345      comes from the N_SO symbol.  For Dwarf it typically comes from the
 346      DW_AT_low_pc attribute of a DW_TAG_compile_unit DIE.  */
 347   CORE_ADDR m_last_source_start_addr;
 348
 349   /* Stack of subfile names.  */
 350   std::vector<const char *> m_subfile_stack;
 351
 352   /* The "using" directives local to lexical context.  */
 353   struct using_direct *m_local_using_directives = nullptr;
 354
 355   /* Global "using" directives.  */
 356   struct using_direct *m_global_using_directives = nullptr;
 357
 358   /* The stack of contexts that are pushed by push_context and popped
 359      by pop_context.  */
 360   std::vector<struct context_stack> m_context_stack;
 361
 362   struct subfile *m_current_subfile = nullptr;
 363
 364   /* The mutable address map for the compilation unit whose symbols
 365      we're currently reading.  The symtabs' shared blockvector will
 366      point to a fixed copy of this.  */
 367   struct addrmap *m_pending_addrmap = nullptr;
 368
 369   /* The obstack on which we allocate pending_addrmap.
 370      If pending_addrmap is NULL, this is uninitialized; otherwise, it is
 371      initialized (and holds pending_addrmap).  */
 372   auto_obstack m_pending_addrmap_obstack;
 373
 374   /* True if we recorded any ranges in the addrmap that are different
 375      from those in the blockvector already.  We set this to false when
 376      we start processing a symfile, and if it's still false at the
 377      end, then we just toss the addrmap.  */
 378   bool m_pending_addrmap_interesting = false;
 379
 380   /* An obstack used for allocating pending blocks.  */
 381   auto_obstack m_pending_block_obstack;
 382
 383   /* Pointer to the head of a linked list of symbol blocks which have
 384      already been finalized (lexical contexts already closed) and which
 385      are just waiting to be built into a blockvector when finalizing the
 386      associated symtab.  */
 387   struct pending_block *m_pending_blocks = nullptr;
 388
 389   /* Pending static symbols and types at the top level.  */
 390   struct pending *m_file_symbols = nullptr;
 391
 392   /* Pending global functions and variables.  */
 393   struct pending *m_global_symbols = nullptr;
 394
 395   /* Pending symbols that are local to the lexical context.  */
 396   struct pending *m_local_symbols = nullptr;
 397 };
 398
 399 \f
 400
 401 extern void add_symbol_to_list (struct symbol *symbol,
 402                                 struct pending **listhead);
 403
 404 extern struct symbol *find_symbol_in_list (struct pending *list,
 405                                            char *name, int length);
 406
 407 #endif /* defined (BUILDSYM_H) */