/* Build symbol tables in GDB's internal format.
- Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1995, 1996,
- 1997, 1998, 1999, 2000, 2002, 2003, 2007 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#if !defined (BUILDSYM_H)
#define BUILDSYM_H 1
+#include "gdb_obstack.h"
+
struct objfile;
struct symbol;
+struct addrmap;
+struct compunit_symtab;
+enum language;
/* This module provides definitions used for creating and adding to
the symbol table. These routines are called from various symbol-
file-reading routines.
They originated in dbxread.c of gdb-4.2, and were split out to
- make xcoffread.c more maintainable by sharing code.
-
- Variables declared in this file can be defined by #define-ing the
- name EXTERN to null. It is used to declare variables that are
- normally extern, but which get defined in a single module using
- this technique. */
+ make xcoffread.c more maintainable by sharing code. */
struct block;
+struct pending_block;
-#ifndef EXTERN
-#define EXTERN extern
-#endif
-
-#define HASHSIZE 127 /* Size of things hashed via
- hashname() */
-
-/* Name of source file whose symbol data we are now processing. This
- comes from a symbol of type N_SO. */
-
-EXTERN char *last_source_file;
-
-/* Core address of start of text of current source file. This too
- comes from the N_SO symbol. */
-
-EXTERN CORE_ADDR last_source_start_addr;
+struct dynamic_prop;
/* The list of sub-source-files within the current individual
compilation. Each file gets its own symtab with its own linetable
and associated info, but they all share one blockvector. */
struct subfile
- {
- struct subfile *next;
- char *name;
- char *dirname;
- struct linetable *line_vector;
- int line_vector_length;
- enum language language;
- char *producer;
- char *debugformat;
- };
-
-EXTERN struct subfile *subfiles;
-
-EXTERN struct subfile *current_subfile;
-
-/* Global variable which, when set, indicates that we are processing a
- .o file compiled with gcc */
-
-EXTERN unsigned char processing_gcc_compilation;
-
-/* When set, we are processing a .o file compiled by sun acc. This is
- misnamed; it refers to all stabs-in-elf implementations which use
- N_UNDF the way Sun does, including Solaris gcc. Hopefully all
- stabs-in-elf implementations ever invented will choose to be
- compatible. */
-
-EXTERN unsigned char processing_acc_compilation;
-
-/* Count symbols as they are processed, for error messages. */
-
-EXTERN unsigned int symnum;
+{
+ struct subfile *next;
+ /* Space for this is malloc'd. */
+ char *name;
+ /* Space for this is malloc'd. */
+ struct linetable *line_vector;
+ int line_vector_length;
+ /* The "containing" compunit. */
+ struct buildsym_compunit *buildsym_compunit;
+ enum language language;
+ struct symtab *symtab;
+};
/* Record the symbols defined for each context in a list. We don't
create a struct block for the context until we know how long to
struct symbol *symbol[PENDINGSIZE];
};
-/* Here are the three lists that symbols are put on. */
-
-/* static at top level, and types */
-
-EXTERN struct pending *file_symbols;
-
-/* global functions and variables */
-
-EXTERN struct pending *global_symbols;
-
-/* everything local to lexical context */
-
-EXTERN struct pending *local_symbols;
-
-/* func params local to lexical context */
-
-EXTERN struct pending *param_symbols;
-
/* Stack representing unclosed lexical contexts (that will become
blocks, eventually). */
struct pending *locals;
- /* Pending func params at the time we entered */
+ /* Pending using directives at the time we entered. */
- struct pending *params;
+ struct using_direct *local_using_directives;
/* Pointer into blocklist as of entry */
struct symbol *name;
+ /* Expression that computes the frame base of the lexically enclosing
+ function, if any. NULL otherwise. */
+
+ struct dynamic_prop *static_link;
+
/* PC where this context starts */
CORE_ADDR start_addr;
- /* Temp slot for exception handling. */
+ /* Temp slot for exception handling. */
CORE_ADDR end_addr;
};
-EXTERN struct context_stack *context_stack;
+/* Buildsym's counterpart to struct compunit_symtab. */
+
+struct buildsym_compunit
+{
+ /* Start recording information about a primary source file (IOW, not an
+ included source file).
+ COMP_DIR is the directory in which the compilation unit was compiled
+ (or NULL if not known). */
+
+ buildsym_compunit (struct objfile *objfile_, const char *name,
+ const char *comp_dir_, enum language language_,
+ CORE_ADDR last_addr);
+
+ /* Reopen an existing compunit_symtab so that additional symbols can
+ be added to it. Arguments are as for the main constructor. CUST
+ is the expandable compunit_symtab to be reopened. */
+
+ buildsym_compunit (struct objfile *objfile_, const char *name,
+ const char *comp_dir_, enum language language_,
+ CORE_ADDR last_addr, struct compunit_symtab *cust)
+ : m_objfile (objfile_),
+ m_last_source_file (name == nullptr ? nullptr : xstrdup (name)),
+ m_comp_dir (comp_dir_ == nullptr ? nullptr : xstrdup (comp_dir_)),
+ m_compunit_symtab (cust),
+ m_language (language_),
+ m_last_source_start_addr (last_addr)
+ {
+ }
+
+ ~buildsym_compunit ();
+
+ DISABLE_COPY_AND_ASSIGN (buildsym_compunit);
+
+ void set_last_source_file (const char *name)
+ {
+ char *new_name = name == NULL ? NULL : xstrdup (name);
+ m_last_source_file.reset (new_name);
+ }
+
+ const char *get_last_source_file ()
+ {
+ return m_last_source_file.get ();
+ }
+
+ struct macro_table *get_macro_table ();
+
+ struct macro_table *release_macros ()
+ {
+ struct macro_table *result = m_pending_macros;
+ m_pending_macros = nullptr;
+ return result;
+ }
+
+ /* This function is called to discard any pending blocks. */
+
+ void free_pending_blocks ()
+ {
+ m_pending_block_obstack.clear ();
+ m_pending_blocks = nullptr;
+ }
-/* Index of first unused entry in context stack. */
+ struct block *finish_block (struct symbol *symbol,
+ struct pending_block *old_blocks,
+ const struct dynamic_prop *static_link,
+ CORE_ADDR start, CORE_ADDR end);
-EXTERN int context_stack_depth;
+ void record_block_range (struct block *block,
+ CORE_ADDR start, CORE_ADDR end_inclusive);
-/* Currently allocated size of context stack. */
+ void start_subfile (const char *name);
-EXTERN int context_stack_size;
+ void patch_subfile_names (struct subfile *subfile, const char *name);
-/* Non-zero if the context stack is empty. */
-#define outermost_context_p() (context_stack_depth == 0)
+ void push_subfile ();
-/* Nonzero if within a function (so symbols should be local, if
- nothing says specifically). */
+ const char *pop_subfile ();
-EXTERN int within_function;
+ void record_line (struct subfile *subfile, int line, CORE_ADDR pc,
+ bool is_stmt);
-/* List of blocks already made (lexical contexts already closed).
- This is used at the end to make the blockvector. */
+ struct compunit_symtab *get_compunit_symtab ()
+ {
+ return m_compunit_symtab;
+ }
-struct pending_block
+ void set_last_source_start_addr (CORE_ADDR addr)
{
- struct pending_block *next;
- struct block *block;
- };
+ m_last_source_start_addr = addr;
+ }
-/* Pointer to the head of a linked list of symbol blocks which have
- already been finalized (lexical contexts already closed) and which
- are just waiting to be built into a blockvector when finalizing the
- associated symtab. */
+ CORE_ADDR get_last_source_start_addr ()
+ {
+ return m_last_source_start_addr;
+ }
-EXTERN struct pending_block *pending_blocks;
-\f
+ struct using_direct **get_local_using_directives ()
+ {
+ return &m_local_using_directives;
+ }
-struct subfile_stack
+ void set_local_using_directives (struct using_direct *new_local)
{
- struct subfile_stack *next;
- char *name;
- };
+ m_local_using_directives = new_local;
+ }
-EXTERN struct subfile_stack *subfile_stack;
+ struct using_direct **get_global_using_directives ()
+ {
+ return &m_global_using_directives;
+ }
-#define next_symbol_text(objfile) (*next_symbol_text_func)(objfile)
+ bool outermost_context_p () const
+ {
+ return m_context_stack.empty ();
+ }
-/* Function to invoke get the next symbol. Return the symbol name. */
+ struct context_stack *get_current_context_stack ()
+ {
+ if (m_context_stack.empty ())
+ return nullptr;
+ return &m_context_stack.back ();
+ }
-EXTERN char *(*next_symbol_text_func) (struct objfile *);
+ int get_context_stack_depth () const
+ {
+ return m_context_stack.size ();
+ }
-/* Vector of types defined so far, indexed by their type numbers.
- Used for both stabs and coff. (In newer sun systems, dbx uses a
- pair of numbers in parens, as in "(SUBFILENUM,NUMWITHINSUBFILE)".
- Then these numbers must be translated through the type_translations
- hash table to get the index into the type vector.) */
+ struct subfile *get_current_subfile ()
+ {
+ return m_current_subfile;
+ }
-EXTERN struct type **type_vector;
+ struct pending **get_local_symbols ()
+ {
+ return &m_local_symbols;
+ }
-/* Number of elements allocated for type_vector currently. */
+ struct pending **get_file_symbols ()
+ {
+ return &m_file_symbols;
+ }
-EXTERN int type_vector_length;
+ struct pending **get_global_symbols ()
+ {
+ return &m_global_symbols;
+ }
-/* Initial size of type vector. Is realloc'd larger if needed, and
- realloc'd down to the size actually used, when completed. */
+ void record_debugformat (const char *format)
+ {
+ m_debugformat = format;
+ }
-#define INITIAL_TYPE_VECTOR_LENGTH 160
+ void record_producer (const char *producer)
+ {
+ m_producer = producer;
+ }
-extern void add_free_pendings (struct pending *list);
+ struct context_stack *push_context (int desc, CORE_ADDR valu);
-extern void add_symbol_to_list (struct symbol *symbol,
- struct pending **listhead);
+ struct context_stack pop_context ();
-extern struct symbol *find_symbol_in_list (struct pending *list,
- char *name, int length);
+ struct block *end_symtab_get_static_block (CORE_ADDR end_addr,
+ int expandable, int required);
+
+ struct compunit_symtab *end_symtab_from_static_block
+ (struct block *static_block, int section, int expandable);
+
+ struct compunit_symtab *end_symtab (CORE_ADDR end_addr, int section);
+
+ struct compunit_symtab *end_expandable_symtab (CORE_ADDR end_addr,
+ int section);
+
+ void augment_type_symtab ();
+
+private:
+
+ void record_pending_block (struct block *block, struct pending_block *opblock);
+
+ struct block *finish_block_internal (struct symbol *symbol,
+ struct pending **listhead,
+ struct pending_block *old_blocks,
+ const struct dynamic_prop *static_link,
+ CORE_ADDR start, CORE_ADDR end,
+ int is_global, int expandable);
+
+ struct blockvector *make_blockvector ();
+
+ void watch_main_source_file_lossage ();
-extern void finish_block (struct symbol *symbol,
- struct pending **listhead,
- struct pending_block *old_blocks,
- CORE_ADDR start, CORE_ADDR end,
- struct objfile *objfile);
+ struct compunit_symtab *end_symtab_with_blockvector
+ (struct block *static_block, int section, int expandable);
-extern void really_free_pendings (void *dummy);
+ /* The objfile we're reading debug info from. */
+ struct objfile *m_objfile;
-extern void start_subfile (char *name, char *dirname);
+ /* List of subfiles (source files).
+ Files are added to the front of the list.
+ This is important mostly for the language determination hacks we use,
+ which iterate over previously added files. */
+ struct subfile *m_subfiles = nullptr;
-extern void patch_subfile_names (struct subfile *subfile, char *name);
+ /* The subfile of the main source file. */
+ struct subfile *m_main_subfile = nullptr;
-extern void push_subfile (void);
+ /* Name of source file whose symbol data we are now processing. This
+ comes from a symbol of type N_SO for stabs. For DWARF it comes
+ from the DW_AT_name attribute of a DW_TAG_compile_unit DIE. */
+ gdb::unique_xmalloc_ptr<char> m_last_source_file;
-extern char *pop_subfile (void);
+ /* E.g., DW_AT_comp_dir if DWARF. Space for this is malloc'd. */
+ gdb::unique_xmalloc_ptr<char> m_comp_dir;
-extern struct symtab *end_symtab (CORE_ADDR end_addr,
- struct objfile *objfile, int section);
+ /* Space for this is not malloc'd, and is assumed to have at least
+ the same lifetime as objfile. */
+ const char *m_producer = nullptr;
-/* Defined in stabsread.c. */
+ /* Space for this is not malloc'd, and is assumed to have at least
+ the same lifetime as objfile. */
+ const char *m_debugformat = nullptr;
-extern void scan_file_globals (struct objfile *objfile);
+ /* The compunit we are building. */
+ struct compunit_symtab *m_compunit_symtab = nullptr;
-extern void buildsym_new_init (void);
+ /* Language of this compunit_symtab. */
+ enum language m_language;
-extern void buildsym_init (void);
+ /* The macro table for the compilation unit whose symbols we're
+ currently reading. */
+ struct macro_table *m_pending_macros = nullptr;
-extern struct context_stack *push_context (int desc, CORE_ADDR valu);
+ /* True if symtab has line number info. This prevents an otherwise
+ empty symtab from being tossed. */
+ bool m_have_line_numbers = false;
-extern struct context_stack *pop_context (void);
+ /* Core address of start of text of current source file. This too
+ comes from the N_SO symbol. For Dwarf it typically comes from the
+ DW_AT_low_pc attribute of a DW_TAG_compile_unit DIE. */
+ CORE_ADDR m_last_source_start_addr;
-extern void record_line (struct subfile *subfile, int line, CORE_ADDR pc);
+ /* Stack of subfile names. */
+ std::vector<const char *> m_subfile_stack;
-extern void start_symtab (char *name, char *dirname, CORE_ADDR start_addr);
+ /* The "using" directives local to lexical context. */
+ struct using_direct *m_local_using_directives = nullptr;
-extern int hashname (char *name);
+ /* Global "using" directives. */
+ struct using_direct *m_global_using_directives = nullptr;
-extern void free_pending_blocks (void);
+ /* The stack of contexts that are pushed by push_context and popped
+ by pop_context. */
+ std::vector<struct context_stack> m_context_stack;
-/* FIXME: Note that this is used only in buildsym.c and dstread.c,
- which should be fixed to not need direct access to
- record_pending_block. */
+ struct subfile *m_current_subfile = nullptr;
-extern void record_pending_block (struct objfile *objfile,
- struct block *block,
- struct pending_block *opblock);
+ /* The mutable address map for the compilation unit whose symbols
+ we're currently reading. The symtabs' shared blockvector will
+ point to a fixed copy of this. */
+ struct addrmap *m_pending_addrmap = nullptr;
-extern void record_debugformat (char *format);
+ /* The obstack on which we allocate pending_addrmap.
+ If pending_addrmap is NULL, this is uninitialized; otherwise, it is
+ initialized (and holds pending_addrmap). */
+ auto_obstack m_pending_addrmap_obstack;
-extern void record_producer (const char *producer);
+ /* True if we recorded any ranges in the addrmap that are different
+ from those in the blockvector already. We set this to false when
+ we start processing a symfile, and if it's still false at the
+ end, then we just toss the addrmap. */
+ bool m_pending_addrmap_interesting = false;
-extern void merge_symbol_lists (struct pending **srclist,
- struct pending **targetlist);
+ /* An obstack used for allocating pending blocks. */
+ auto_obstack m_pending_block_obstack;
-/* The macro table for the compilation unit whose symbols we're
- currently reading. All the symtabs for this CU will point to this. */
-EXTERN struct macro_table *pending_macros;
+ /* Pointer to the head of a linked list of symbol blocks which have
+ already been finalized (lexical contexts already closed) and which
+ are just waiting to be built into a blockvector when finalizing the
+ associated symtab. */
+ struct pending_block *m_pending_blocks = nullptr;
-#undef EXTERN
+ /* Pending static symbols and types at the top level. */
+ struct pending *m_file_symbols = nullptr;
+
+ /* Pending global functions and variables. */
+ struct pending *m_global_symbols = nullptr;
+
+ /* Pending symbols that are local to the lexical context. */
+ struct pending *m_local_symbols = nullptr;
+};
+
+\f
+
+extern void add_symbol_to_list (struct symbol *symbol,
+ struct pending **listhead);
+
+extern struct symbol *find_symbol_in_list (struct pending *list,
+ char *name, int length);
#endif /* defined (BUILDSYM_H) */