/* Build symbol tables in GDB's internal format.
- Copyright 1986-1993, 1996-1999 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, 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. */
-
-#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. */
+ make xcoffread.c more maintainable by sharing code. */
-EXTERN char *last_source_file;
+struct block;
+struct pending_block;
-/* 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 *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;
-
-/* elz: added this flag to know when a block is compiled with HP
- compilers (cc, aCC). This is necessary because of the macro
- COERCE_FLOAT_TO_DOUBLE defined in tm_hppa.h, which causes a
- coercion of float to double to always occur in parameter passing
- for a function called by gdb (see the function value_arg_coerce in
- valops.c). This is necessary only if the target was compiled with
- gcc, not with HP compilers or with g++ */
-
-EXTERN unsigned char processing_hp_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. */
-/* Index of first unused entry in context stack. */
+ void free_pending_blocks ()
+ {
+ m_pending_block_obstack.clear ();
+ m_pending_blocks = nullptr;
+ }
-EXTERN int context_stack_depth;
+ struct block *finish_block (struct symbol *symbol,
+ struct pending_block *old_blocks,
+ const struct dynamic_prop *static_link,
+ CORE_ADDR start, CORE_ADDR end);
-/* Currently allocated size of context stack. */
+ void record_block_range (struct block *block,
+ CORE_ADDR start, CORE_ADDR end_inclusive);
-EXTERN int context_stack_size;
+ void start_subfile (const char *name);
-/* Macro "function" for popping contexts from the stack. Pushing is
- done by a real function, push_context. This returns a pointer to a
- struct context_stack. */
+ void patch_subfile_names (struct subfile *subfile, const char *name);
-#define pop_context() (&context_stack[--context_stack_depth]);
+ 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);
-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_from_static_block
+ (struct block *static_block, int section, int expandable);
-extern void really_free_pendings (PTR dummy);
+ struct compunit_symtab *end_symtab (CORE_ADDR end_addr, int section);
-extern void start_subfile (char *name, char *dirname);
+ struct compunit_symtab *end_expandable_symtab (CORE_ADDR end_addr,
+ int section);
-extern void patch_subfile_names (struct subfile *subfile, char *name);
+ void augment_type_symtab ();
-extern void push_subfile (void);
+private:
-extern char *pop_subfile (void);
+ void record_pending_block (struct block *block, struct pending_block *opblock);
-extern struct symtab *end_symtab (CORE_ADDR end_addr,
- struct objfile *objfile, int section);
+ 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);
-/* Defined in stabsread.c. */
+ struct blockvector *make_blockvector ();
-extern void scan_file_globals (struct objfile *objfile);
+ void watch_main_source_file_lossage ();
-extern void buildsym_new_init (void);
+ struct compunit_symtab *end_symtab_with_blockvector
+ (struct block *static_block, int section, int expandable);
-extern void buildsym_init (void);
+ /* The objfile we're reading debug info from. */
+ struct objfile *m_objfile;
-extern struct context_stack *push_context (int desc, CORE_ADDR valu);
+ /* 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 record_line (struct subfile *subfile, int line, CORE_ADDR pc);
+ /* The subfile of the main source file. */
+ struct subfile *m_main_subfile = nullptr;
-extern void start_symtab (char *name, char *dirname, CORE_ADDR start_addr);
+ /* 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 int hashname (char *name);
+ /* E.g., DW_AT_comp_dir if DWARF. Space for this is malloc'd. */
+ gdb::unique_xmalloc_ptr<char> m_comp_dir;
-extern void free_pending_blocks (void);
+ /* Space for this is not malloc'd, and is assumed to have at least
+ the same lifetime as objfile. */
+ const char *m_producer = nullptr;
-/* FIXME: Note that this is used only in buildsym.c and dstread.c,
- which should be fixed to not need direct access to
- make_blockvector. */
+ /* 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 struct blockvector *make_blockvector (struct objfile *objfile);
+ /* The compunit we are building. */
+ struct compunit_symtab *m_compunit_symtab = nullptr;
-/* 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. */
+ /* Language of this compunit_symtab. */
+ enum language m_language;
-extern void record_pending_block (struct objfile *objfile,
- struct block *block,
- struct pending_block *opblock);
+ /* The macro table for the compilation unit whose symbols we're
+ currently reading. */
+ struct macro_table *m_pending_macros = nullptr;
-extern void record_debugformat (char *format);
+ /* True if symtab has line number info. This prevents an otherwise
+ empty symtab from being tossed. */
+ bool m_have_line_numbers = false;
-extern void merge_symbol_lists (struct pending **srclist,
- struct pending **targetlist);
+ /* 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;
-#undef EXTERN
+ /* Stack of subfile names. */
+ std::vector<const char *> m_subfile_stack;
+
+ /* The "using" directives local to lexical context. */
+ struct using_direct *m_local_using_directives = nullptr;
+
+ /* Global "using" directives. */
+ struct using_direct *m_global_using_directives = nullptr;
+
+ /* The stack of contexts that are pushed by push_context and popped
+ by pop_context. */
+ std::vector<struct context_stack> m_context_stack;
+
+ struct subfile *m_current_subfile = nullptr;
+
+ /* 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;
+
+ /* 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;
+
+ /* 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;
+
+ /* An obstack used for allocating pending blocks. */
+ auto_obstack m_pending_block_obstack;
+
+ /* 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;
+
+ /* 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) */
projects / deliverable / binutils-gdb.git / blobdiff