/* Support routines for decoding "stabs" debugging information format.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "libaout.h"
#include "aout/aout64.h"
#include "gdb-stabs.h"
-#include "buildsym.h"
+#include "buildsym-legacy.h"
#include "complaints.h"
#include "demangle.h"
#include "gdb-demangle.h"
#include "cp-support.h"
#include <ctype.h>
-/* Ask stabsread.h to define the vars it normally declares `extern'. */
-#define EXTERN
-/**/
-#include "stabsread.h" /* Our own declarations */
-#undef EXTERN
+#include "stabsread.h"
+
+/* See stabsread.h for these globals. */
+unsigned int symnum;
+const char *(*next_symbol_text_func) (struct objfile *);
+unsigned char processing_gcc_compilation;
+int within_function;
+struct symbol *global_sym_chain[HASHSIZE];
+struct pending_stabs *global_stabs;
+int previous_stab_code;
+int *this_object_header_files;
+int n_this_object_header_files;
+int n_allocated_this_object_header_files;
struct nextfield
{
This is part of some reorganization of low level C++ support and is
expected to eventually go away... (FIXME) */
-struct field_info
+struct stab_field_info
{
- struct nextfield *list;
- struct next_fnfieldlist *fnlist;
+ struct nextfield *list = nullptr;
+ struct next_fnfieldlist *fnlist = nullptr;
+
+ auto_obstack obstack;
};
static void
-read_one_struct_field (struct field_info *, const char **, const char *,
+read_one_struct_field (struct stab_field_info *, const char **, const char *,
struct type *, struct objfile *);
static struct type *dbx_alloc_type (int[2], struct objfile *);
static struct type *rs6000_builtin_type (int, struct objfile *);
static int
-read_member_functions (struct field_info *, const char **, struct type *,
+read_member_functions (struct stab_field_info *, const char **, struct type *,
struct objfile *);
static int
-read_struct_fields (struct field_info *, const char **, struct type *,
+read_struct_fields (struct stab_field_info *, const char **, struct type *,
struct objfile *);
static int
-read_baseclasses (struct field_info *, const char **, struct type *,
+read_baseclasses (struct stab_field_info *, const char **, struct type *,
struct objfile *);
static int
-read_tilde_fields (struct field_info *, const char **, struct type *,
+read_tilde_fields (struct stab_field_info *, const char **, struct type *,
struct objfile *);
-static int attach_fn_fields_to_type (struct field_info *, struct type *);
+static int attach_fn_fields_to_type (struct stab_field_info *, struct type *);
-static int attach_fields_to_type (struct field_info *, struct type *,
+static int attach_fields_to_type (struct stab_field_info *, struct type *,
struct objfile *);
static struct type *read_struct_type (const char **, struct type *,
static void add_undefined_type (struct type *, int[2]);
static int
-read_cpp_abbrev (struct field_info *, const char **, struct type *,
+read_cpp_abbrev (struct stab_field_info *, const char **, struct type *,
struct objfile *);
static const char *find_name_end (const char *name);
{
SYMBOL_TYPE (sym) = read_type (&pp, objfile);
}
- add_symbol_to_list (sym, &global_symbols);
+ add_symbol_to_list (sym, get_global_symbols ());
}
else
{
{
int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
- if (regno < 0
- || regno >= (gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch)))
+ if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch))
{
- reg_value_complaint (regno,
- gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch),
+ reg_value_complaint (regno, gdbarch_num_cooked_regs (gdbarch),
SYMBOL_PRINT_NAME (sym));
regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless. */
SYMBOL_LINE (sym) = 0; /* unknown */
}
- SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
+ SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language,
&objfile->objfile_obstack);
if (is_cplus_marker (string[0]))
SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile);
if (SYMBOL_LANGUAGE (sym) == language_cplus)
- cp_scan_for_anonymous_namespaces (sym, objfile);
+ cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym,
+ objfile);
}
p++;
SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &file_symbols);
+ add_symbol_to_list (sym, get_file_symbols ());
return sym;
}
++p;
SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &file_symbols);
+ add_symbol_to_list (sym, get_file_symbols ());
return sym;
}
SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &file_symbols);
+ add_symbol_to_list (sym, get_file_symbols ());
return sym;
}
}
}
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &file_symbols);
+ add_symbol_to_list (sym, get_file_symbols ());
return sym;
case 'C':
SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE_ADDRESS (sym) = valu;
- add_symbol_to_list (sym, &local_symbols);
+ add_symbol_to_list (sym, get_local_symbols ());
break;
case 'f':
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &file_symbols);
+ add_symbol_to_list (sym, get_file_symbols ());
/* fall into process_function_types. */
process_function_types:
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &global_symbols);
+ add_symbol_to_list (sym, get_global_symbols ());
goto process_function_types;
case 'G':
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
}
- add_symbol_to_list (sym, &global_symbols);
+ add_symbol_to_list (sym, get_global_symbols ());
break;
/* This case is faked by a conditional above,
SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &local_symbols);
+ add_symbol_to_list (sym, get_local_symbols ());
break;
case 'p':
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_IS_ARGUMENT (sym) = 1;
- add_symbol_to_list (sym, &local_symbols);
+ add_symbol_to_list (sym, get_local_symbols ());
if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
{
SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &local_symbols);
+ add_symbol_to_list (sym, get_local_symbols ());
break;
case 'r':
but this case is considered pathological and causes a warning
from a decent compiler. */
+ struct pending *local_symbols = *get_local_symbols ();
if (local_symbols
&& local_symbols->nsyms > 0
&& gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
break;
}
}
- add_symbol_to_list (sym, &local_symbols);
+ add_symbol_to_list (sym, get_local_symbols ());
}
else
- add_symbol_to_list (sym, &file_symbols);
+ add_symbol_to_list (sym, get_file_symbols ());
break;
case 'S':
}
}
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &file_symbols);
+ add_symbol_to_list (sym, get_file_symbols ());
break;
case 't':
*/
/* Pascal accepts names for pointer types. */
- if (current_subfile->language == language_pascal)
+ if (get_current_subfile ()->language == language_pascal)
{
TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
}
TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
}
- add_symbol_to_list (sym, &file_symbols);
+ add_symbol_to_list (sym, get_file_symbols ());
if (synonym)
{
= obconcat (&objfile->objfile_obstack,
SYMBOL_LINKAGE_NAME (sym),
(char *) NULL);
- add_symbol_to_list (struct_sym, &file_symbols);
+ add_symbol_to_list (struct_sym, get_file_symbols ());
}
break;
= obconcat (&objfile->objfile_obstack,
SYMBOL_LINKAGE_NAME (sym),
(char *) NULL);
- add_symbol_to_list (sym, &file_symbols);
+ add_symbol_to_list (sym, get_file_symbols ());
if (synonym)
{
= obconcat (&objfile->objfile_obstack,
SYMBOL_LINKAGE_NAME (sym),
(char *) NULL);
- add_symbol_to_list (typedef_sym, &file_symbols);
+ add_symbol_to_list (typedef_sym, get_file_symbols ());
}
break;
}
}
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &local_symbols);
+ add_symbol_to_list (sym, get_local_symbols ());
break;
case 'v':
SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &local_symbols);
+ add_symbol_to_list (sym, get_local_symbols ());
break;
case 'a':
SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &local_symbols);
+ add_symbol_to_list (sym, get_local_symbols ());
break;
case 'X':
SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &local_symbols);
+ add_symbol_to_list (sym, get_local_symbols ());
break;
default:
SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_VALUE (sym) = 0;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, &file_symbols);
+ add_symbol_to_list (sym, get_file_symbols ());
break;
}
return error_type (pp, objfile);
}
type_name = NULL;
- if (current_subfile->language == language_cplus)
+ if (get_current_subfile ()->language == language_cplus)
{
char *name = (char *) alloca (p - *pp + 1);
type, rather than allocating a new one. This saves some
memory. */
- for (ppt = file_symbols; ppt; ppt = ppt->next)
+ for (ppt = *get_file_symbols (); ppt; ppt = ppt->next)
for (i = 0; i < ppt->nsyms; i++)
{
struct symbol *sym = ppt->symbol[i];
case 'S': /* Set type */
type1 = read_type (pp, objfile);
- type = create_set_type ((struct type *) NULL, type1);
+ type = create_set_type (NULL, type1);
if (typenums[0] != -1)
*dbx_lookup_type (typenums, objfile) = type;
break;
/* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
Return the proper type node for a given builtin type number. */
-static const struct objfile_data *rs6000_builtin_type_data;
+static const struct objfile_key<struct type *,
+ gdb::noop_deleter<struct type *>>
+ rs6000_builtin_type_data;
static struct type *
rs6000_builtin_type (int typenum, struct objfile *objfile)
{
- struct type **negative_types
- = (struct type **) objfile_data (objfile, rs6000_builtin_type_data);
+ struct type **negative_types = rs6000_builtin_type_data.get (objfile);
/* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
#define NUMBER_RECOGNIZED 34
/* This includes an empty slot for type number -0. */
negative_types = OBSTACK_CALLOC (&objfile->objfile_obstack,
NUMBER_RECOGNIZED + 1, struct type *);
- set_objfile_data (objfile, rs6000_builtin_type_data, negative_types);
+ rs6000_builtin_type_data.set (objfile, negative_types);
}
if (negative_types[-typenum] != NULL)
Returns 1 for success, 0 for failure. */
static int
-read_member_functions (struct field_info *fip, const char **pp,
+read_member_functions (struct stab_field_info *fip, const char **pp,
struct type *type, struct objfile *objfile)
{
int nfn_fields = 0;
look_ahead_type = NULL;
length = 0;
- new_fnlist = XCNEW (struct next_fnfieldlist);
- make_cleanup (xfree, new_fnlist);
+ new_fnlist = OBSTACK_ZALLOC (&fip->obstack, struct next_fnfieldlist);
if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
{
do
{
- new_sublist = XCNEW (struct next_fnfield);
- make_cleanup (xfree, new_sublist);
+ new_sublist = OBSTACK_ZALLOC (&fip->obstack, struct next_fnfield);
/* Check for and handle cretinous dbx symbol name continuation! */
if (look_ahead_type == NULL)
}
else
{
- int has_stub = 0;
int has_destructor = 0, has_other = 0;
int is_v3 = 0;
struct next_fnfield *tmp_sublist;
tmp_sublist = sublist;
while (tmp_sublist != NULL)
{
- if (tmp_sublist->fn_field.is_stub)
- has_stub = 1;
if (tmp_sublist->fn_field.physname[0] == '_'
&& tmp_sublist->fn_field.physname[1] == 'Z')
is_v3 = 1;
/* Create a new fn_fieldlist for the destructors. */
- destr_fnlist = XCNEW (struct next_fnfieldlist);
- make_cleanup (xfree, destr_fnlist);
+ destr_fnlist = OBSTACK_ZALLOC (&fip->obstack,
+ struct next_fnfieldlist);
destr_fnlist->fn_fieldlist.name
= obconcat (&objfile->objfile_obstack, "~",
"~", main_fn_name, (char *)NULL);
xfree (main_fn_name);
}
- else if (!has_stub)
- {
- char dem_opname[256];
- int ret;
-
- ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
- dem_opname, DMGL_ANSI);
- if (!ret)
- ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
- dem_opname, 0);
- if (ret)
- new_fnlist->fn_fieldlist.name
- = ((const char *)
- obstack_copy0 (&objfile->objfile_obstack, dem_opname,
- strlen (dem_opname)));
- xfree (main_fn_name);
- }
new_fnlist->fn_fieldlist.fn_fields
= OBSTACK_CALLOC (&objfile->objfile_obstack, length, fn_field);
keep parsing and it's time for error_type(). */
static int
-read_cpp_abbrev (struct field_info *fip, const char **pp, struct type *type,
- struct objfile *objfile)
+read_cpp_abbrev (struct stab_field_info *fip, const char **pp,
+ struct type *type, struct objfile *objfile)
{
const char *p;
const char *name;
}
static void
-read_one_struct_field (struct field_info *fip, const char **pp, const char *p,
- struct type *type, struct objfile *objfile)
+read_one_struct_field (struct stab_field_info *fip, const char **pp,
+ const char *p, struct type *type,
+ struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
Returns 1 for success, 0 for failure. */
static int
-read_struct_fields (struct field_info *fip, const char **pp, struct type *type,
- struct objfile *objfile)
+read_struct_fields (struct stab_field_info *fip, const char **pp,
+ struct type *type, struct objfile *objfile)
{
const char *p;
struct nextfield *newobj;
{
STABS_CONTINUE (pp, objfile);
/* Get space to record the next field's data. */
- newobj = XCNEW (struct nextfield);
- make_cleanup (xfree, newobj);
+ newobj = OBSTACK_ZALLOC (&fip->obstack, struct nextfield);
newobj->next = fip->list;
fip->list = newobj;
static int
-read_baseclasses (struct field_info *fip, const char **pp, struct type *type,
- struct objfile *objfile)
+read_baseclasses (struct stab_field_info *fip, const char **pp,
+ struct type *type, struct objfile *objfile)
{
int i;
struct nextfield *newobj;
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
- newobj = XCNEW (struct nextfield);
- make_cleanup (xfree, newobj);
+ newobj = OBSTACK_ZALLOC (&fip->obstack, struct nextfield);
newobj->next = fip->list;
fip->list = newobj;
so we can look for the vptr base class info. */
static int
-read_tilde_fields (struct field_info *fip, const char **pp, struct type *type,
- struct objfile *objfile)
+read_tilde_fields (struct stab_field_info *fip, const char **pp,
+ struct type *type, struct objfile *objfile)
{
const char *p;
}
static int
-attach_fn_fields_to_type (struct field_info *fip, struct type *type)
+attach_fn_fields_to_type (struct stab_field_info *fip, struct type *type)
{
int n;
for this class's virtual functions. */
static int
-attach_fields_to_type (struct field_info *fip, struct type *type,
+attach_fields_to_type (struct stab_field_info *fip, struct type *type,
struct objfile *objfile)
{
int nfields = 0;
read_struct_type (const char **pp, struct type *type, enum type_code type_code,
struct objfile *objfile)
{
- struct cleanup *back_to;
- struct field_info fi;
-
- fi.list = NULL;
- fi.fnlist = NULL;
+ struct stab_field_info fi;
/* When describing struct/union/class types in stabs, G++ always drops
all qualifications from the name. So if you've got:
return type;
}
- back_to = make_cleanup (null_cleanup, 0);
-
INIT_CPLUS_SPECIFIC (type);
TYPE_CODE (type) = type_code;
TYPE_STUB (type) = 0;
TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
if (nbits != 0)
- {
- do_cleanups (back_to);
- return error_type (pp, objfile);
- }
+ return error_type (pp, objfile);
set_length_in_type_chain (type);
}
type = error_type (pp, objfile);
}
- do_cleanups (back_to);
return (type);
}
}
range_type =
- create_static_range_type ((struct type *) NULL, index_type, lower, upper);
+ create_static_range_type (NULL, index_type, lower, upper);
type = create_array_type (type, element_type, range_type);
return type;
to be file-scope, between N_FN entries, using N_LSYM. What's a mother
to do? For now, force all enum values to file scope. */
if (within_function)
- symlist = &local_symbols;
+ symlist = get_local_symbols ();
else
#endif
- symlist = &file_symbols;
+ symlist = get_file_symbols ();
osyms = *symlist;
o_nsyms = osyms ? osyms->nsyms : 0;
sym = allocate_symbol (objfile);
SYMBOL_SET_LINKAGE_NAME (sym, name);
- SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
+ SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language,
&objfile->objfile_obstack);
SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
}
result_type
- = create_static_range_type ((struct type *) NULL, index_type, n2, n3);
+ = create_static_range_type (NULL, index_type, n2, n3);
return (result_type);
}
{
complaint (_("Invalid symbol data: common block within common block"));
}
- common_block = local_symbols;
- common_block_i = local_symbols ? local_symbols->nsyms : 0;
+ common_block = *get_local_symbols ();
+ common_block_i = common_block ? common_block->nsyms : 0;
common_block_name = (char *) obstack_copy0 (&objfile->objfile_obstack, name,
strlen (name));
}
/* Now we copy all the symbols which have been defined since the BCOMM. */
/* Copy all the struct pendings before common_block. */
- for (next = local_symbols;
+ for (next = *get_local_symbols ();
next != NULL && next != common_block;
next = next->next)
{
complaint (_("need a type name"));
break;
}
- for (ppt = file_symbols; ppt; ppt = ppt->next)
+ for (ppt = *get_file_symbols (); ppt; ppt = ppt->next)
{
for (i = 0; i < ppt->nsyms; i++)
{
cleanup_undefined_types_noname (objfile);
}
-/* Scan through all of the global symbols defined in the object file,
- assigning values to the debugging symbols that need to be assigned
- to. Get these symbols from the minimal symbol table. */
+/* See stabsread.h. */
void
scan_file_globals (struct objfile *objfile)
{
int hash;
- struct minimal_symbol *msymbol;
struct symbol *sym, *prev;
struct objfile *resolve_objfile;
if (hash >= HASHSIZE)
return;
- ALL_OBJFILE_MSYMBOLS (resolve_objfile, msymbol)
+ for (minimal_symbol *msymbol : resolve_objfile->msymbols ())
{
QUIT;
n_this_object_header_files = 1;
type_vector_length = 0;
type_vector = (struct type **) 0;
+ within_function = 0;
/* FIXME: If common_block_name is not already NULL, we should complain(). */
common_block_name = NULL;
{
if (global_stabs)
{
- patch_block_stabs (global_symbols, global_stabs, objfile);
+ patch_block_stabs (*get_global_symbols (), global_stabs, objfile);
xfree (global_stabs);
global_stabs = NULL;
}
}
}
+/* See stabsread.h. */
+
+int
+hashname (const char *name)
+{
+ return hash (name, strlen (name)) % HASHSIZE;
+}
+
/* Initializer for this module. */
void
_initialize_stabsread (void)
{
- rs6000_builtin_type_data = register_objfile_data ();
-
undef_types_allocated = 20;
undef_types_length = 0;
undef_types = XNEWVEC (struct type *, undef_types_allocated);