X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fstabsread.c;h=179a0fb610bc8f9b2d1330ec924db8b5875f1999;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=27414a9812aa2414cc35b7f9d85fa709a55053c9;hpb=d772d2abcc163142fc38655896c4704b06dae0b6;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/stabsread.c b/gdb/stabsread.c index 27414a9812..179a0fb610 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -1,6 +1,6 @@ /* Support routines for decoding "stabs" debugging information format. - Copyright (C) 1986-2019 Free Software Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -42,6 +42,7 @@ #include "gdb-demangle.h" #include "language.h" #include "target-float.h" +#include "c-lang.h" #include "cp-abi.h" #include "cp-support.h" #include @@ -368,7 +369,7 @@ dbx_alloc_type (int typenums[2], struct objfile *objfile) static struct type * dbx_init_float_type (struct objfile *objfile, int bits) { - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); const struct floatformat **format; struct type *type; @@ -422,12 +423,11 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs, /* On xcoff, if a global is defined and never referenced, ld will remove it from the executable. There is then a N_GSYM stab for it, but no regular (C_EXT) symbol. */ - sym = allocate_symbol (objfile); + sym = new (&objfile->objfile_obstack) symbol; SYMBOL_DOMAIN (sym) = VAR_DOMAIN; SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT; - SYMBOL_SET_LINKAGE_NAME - (sym, (char *) obstack_copy0 (&objfile->objfile_obstack, - name, pp - name)); + sym->set_linkage_name + (obstack_strndup (&objfile->objfile_obstack, name, pp - name)); pp += 2; if (*(pp - 1) == 'F' || *(pp - 1) == 'f') { @@ -628,7 +628,7 @@ stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch) if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch)) { reg_value_complaint (regno, gdbarch_num_cooked_regs (gdbarch), - SYMBOL_PRINT_NAME (sym)); + sym->print_name ()); regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless. */ } @@ -649,7 +649,7 @@ struct symbol * define_symbol (CORE_ADDR valu, const char *string, int desc, int type, struct objfile *objfile) { - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); struct symbol *sym; const char *p = find_name_end (string); int deftype; @@ -687,7 +687,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */ nameless = (p == string || ((string[0] == ' ') && (string[1] == ':'))); - current_symbol = sym = allocate_symbol (objfile); + current_symbol = sym = new (&objfile->objfile_obstack) symbol; if (processing_gcc_compilation) { @@ -700,8 +700,8 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, SYMBOL_LINE (sym) = 0; /* unknown */ } - SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language, - &objfile->objfile_obstack); + sym->set_language (get_current_subfile ()->language, + &objfile->objfile_obstack); if (is_cplus_marker (string[0])) { @@ -709,14 +709,14 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, switch (string[1]) { case 't': - SYMBOL_SET_LINKAGE_NAME (sym, "this"); + sym->set_linkage_name ("this"); break; case 'v': /* $vtbl_ptr_type */ goto normal; case 'e': - SYMBOL_SET_LINKAGE_NAME (sym, "eh_throw"); + sym->set_linkage_name ("eh_throw"); break; case '_': @@ -738,9 +738,9 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, else { normal: - std::string new_name; + gdb::unique_xmalloc_ptr new_name; - if (SYMBOL_LANGUAGE (sym) == language_cplus) + if (sym->language () == language_cplus) { char *name = (char *) alloca (p - string + 1); @@ -748,16 +748,13 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, name[p - string] = '\0'; new_name = cp_canonicalize_string (name); } - if (!new_name.empty ()) - { - SYMBOL_SET_NAMES (sym, - new_name.c_str (), new_name.length (), - 1, objfile); - } + if (new_name != nullptr) + sym->compute_and_set_names (new_name.get (), true, objfile->per_bfd); else - SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile); + sym->compute_and_set_names (gdb::string_view (string, p - string), true, + objfile->per_bfd); - if (SYMBOL_LANGUAGE (sym) == language_cplus) + if (sym->language () == language_cplus) cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym, objfile); @@ -942,7 +939,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, SYMBOL_TYPE (sym) = read_type (&p, objfile); SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL; SYMBOL_DOMAIN (sym) = VAR_DOMAIN; - SYMBOL_VALUE_ADDRESS (sym) = valu; + SET_SYMBOL_VALUE_ADDRESS (sym, valu); add_symbol_to_list (sym, get_local_symbols ()); break; @@ -958,7 +955,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, /* Function result types are described as the result type in stabs. We need to convert this to the function-returning-type-X type in GDB. E.g. "int" is converted to "function returning int". */ - if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_FUNC) + if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_FUNC) SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym)); /* All functions in C++ have prototypes. Stabs does not offer an @@ -989,8 +986,9 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, } /* Allocate parameter information fields and fill them in. */ - TYPE_FIELDS (ftype) = (struct field *) - TYPE_ALLOC (ftype, nsemi * sizeof (struct field)); + ftype->set_fields + ((struct field *) + TYPE_ALLOC (ftype, nsemi * sizeof (struct field))); while (*p++ == ';') { struct type *ptype; @@ -1007,12 +1005,12 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, a TYPE_CODE_VOID type by read_type, and we have to turn it back into builtin_int here. FIXME: Do we need a new builtin_promoted_int_arg ? */ - if (TYPE_CODE (ptype) == TYPE_CODE_VOID) + if (ptype->code () == TYPE_CODE_VOID) ptype = objfile_type (objfile)->builtin_int; TYPE_FIELD_TYPE (ftype, nparams) = ptype; TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0; } - TYPE_NFIELDS (ftype) = nparams; + ftype->set_num_fields (nparams); TYPE_PROTOTYPED (ftype) = 1; } break; @@ -1037,9 +1035,9 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, Symbol references don't have valid names and wont't match up with minimal symbols when the global_sym_chain is relocated. We'll fixup symbol references when we fixup the defining symbol. */ - if (SYMBOL_LINKAGE_NAME (sym) && SYMBOL_LINKAGE_NAME (sym)[0] != '#') + if (sym->linkage_name () && sym->linkage_name ()[0] != '#') { - i = hashname (SYMBOL_LINKAGE_NAME (sym)); + i = hashname (sym->linkage_name ()); SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i]; global_sym_chain[i] = sym; } @@ -1096,7 +1094,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, really an int. */ if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT - && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT) + && SYMBOL_TYPE (sym)->code () == TYPE_CODE_INT) { SYMBOL_TYPE (sym) = TYPE_UNSIGNED (SYMBOL_TYPE (sym)) @@ -1140,8 +1138,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, the same name to represent an argument passed in a register. GCC uses 'P' for the same case. So if we find such a symbol pair we combine it into one 'P' symbol. - For Sun cc we need to do this regardless of - stabs_argument_has_addr, because the compiler puts out + For Sun cc we need to do this regardless of stabs_argument_has_addr, because the compiler puts out the 'p' symbol even if it never saves the argument onto the stack. @@ -1166,8 +1163,8 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, prev_sym = local_symbols->symbol[local_symbols->nsyms - 1]; if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG || SYMBOL_CLASS (prev_sym) == LOC_ARG) - && strcmp (SYMBOL_LINKAGE_NAME (prev_sym), - SYMBOL_LINKAGE_NAME (sym)) == 0) + && strcmp (prev_sym->linkage_name (), + sym->linkage_name ()) == 0) { SYMBOL_ACLASS_INDEX (prev_sym) = stab_register_index; /* Use the type from the LOC_REGISTER; that is the type @@ -1188,23 +1185,22 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, /* Static symbol at top level of file. */ SYMBOL_TYPE (sym) = read_type (&p, objfile); SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC; - SYMBOL_VALUE_ADDRESS (sym) = valu; + SET_SYMBOL_VALUE_ADDRESS (sym, valu); if (gdbarch_static_transform_name_p (gdbarch) - && gdbarch_static_transform_name (gdbarch, - SYMBOL_LINKAGE_NAME (sym)) - != SYMBOL_LINKAGE_NAME (sym)) + && gdbarch_static_transform_name (gdbarch, sym->linkage_name ()) + != sym->linkage_name ()) { struct bound_minimal_symbol msym; - msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), - NULL, objfile); + msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile); if (msym.minsym != NULL) { const char *new_name = gdbarch_static_transform_name - (gdbarch, SYMBOL_LINKAGE_NAME (sym)); + (gdbarch, sym->linkage_name ()); - SYMBOL_SET_LINKAGE_NAME (sym, new_name); - SYMBOL_VALUE_ADDRESS (sym) = BMSYMBOL_VALUE_ADDRESS (msym); + sym->set_linkage_name (new_name); + SET_SYMBOL_VALUE_ADDRESS (sym, + BMSYMBOL_VALUE_ADDRESS (msym)); } } SYMBOL_DOMAIN (sym) = VAR_DOMAIN; @@ -1226,7 +1222,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, This is important to do, because of forward references: The cleanup of undefined types stored in undef_types only uses STRUCT_DOMAIN symbols to perform the replacement. */ - synonym = (SYMBOL_LANGUAGE (sym) == language_ada && p[-2] != 'T'); + synonym = (sym->language () == language_ada && p[-2] != 'T'); /* Typedef */ SYMBOL_TYPE (sym) = read_type (&p, objfile); @@ -1243,9 +1239,9 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, a base type which did not have its name defined when the derived class was output. We fill in the derived class's base part member's name here in that case. */ - if (TYPE_NAME (SYMBOL_TYPE (sym)) != NULL) - if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT - || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION) + if (SYMBOL_TYPE (sym)->name () != NULL) + if ((SYMBOL_TYPE (sym)->code () == TYPE_CODE_STRUCT + || SYMBOL_TYPE (sym)->code () == TYPE_CODE_UNION) && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym))) { int j; @@ -1253,19 +1249,14 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--) if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0) TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) = - TYPE_NAME (TYPE_BASECLASS (SYMBOL_TYPE (sym), j)); + TYPE_BASECLASS (SYMBOL_TYPE (sym), j)->name (); } - if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL) + if (SYMBOL_TYPE (sym)->name () == NULL) { - /* gcc-2.6 or later (when using -fvtable-thunks) - emits a unique named type for a vtable entry. - Some gdb code depends on that specific name. */ - extern const char vtbl_ptr_name[]; - - if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR - && strcmp (SYMBOL_LINKAGE_NAME (sym), vtbl_ptr_name)) - || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC) + if ((SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR + && strcmp (sym->linkage_name (), vtbl_ptr_name)) + || SYMBOL_TYPE (sym)->code () == TYPE_CODE_FUNC) { /* If we are giving a name to a type such as "pointer to foo" or "function returning foo", we better not set @@ -1304,12 +1295,10 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, /* Pascal accepts names for pointer types. */ if (get_current_subfile ()->language == language_pascal) - { - TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym); - } + SYMBOL_TYPE (sym)->set_name (sym->linkage_name ()); } else - TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym); + SYMBOL_TYPE (sym)->set_name (sym->linkage_name ()); } add_symbol_to_list (sym, get_file_symbols ()); @@ -1317,20 +1306,19 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, if (synonym) { /* Create the STRUCT_DOMAIN clone. */ - struct symbol *struct_sym = allocate_symbol (objfile); + struct symbol *struct_sym = new (&objfile->objfile_obstack) symbol; *struct_sym = *sym; SYMBOL_ACLASS_INDEX (struct_sym) = LOC_TYPEDEF; SYMBOL_VALUE (struct_sym) = valu; SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN; - if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) - TYPE_NAME (SYMBOL_TYPE (sym)) - = obconcat (&objfile->objfile_obstack, - SYMBOL_LINKAGE_NAME (sym), - (char *) NULL); + if (SYMBOL_TYPE (sym)->name () == 0) + SYMBOL_TYPE (sym)->set_name + (obconcat (&objfile->objfile_obstack, sym->linkage_name (), + (char *) NULL)); add_symbol_to_list (struct_sym, get_file_symbols ()); } - + break; case 'T': @@ -1351,27 +1339,25 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF; SYMBOL_VALUE (sym) = valu; SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; - if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) - TYPE_NAME (SYMBOL_TYPE (sym)) - = obconcat (&objfile->objfile_obstack, - SYMBOL_LINKAGE_NAME (sym), - (char *) NULL); + if (SYMBOL_TYPE (sym)->name () == 0) + SYMBOL_TYPE (sym)->set_name + (obconcat (&objfile->objfile_obstack, sym->linkage_name (), + (char *) NULL)); add_symbol_to_list (sym, get_file_symbols ()); if (synonym) { /* Clone the sym and then modify it. */ - struct symbol *typedef_sym = allocate_symbol (objfile); + struct symbol *typedef_sym = new (&objfile->objfile_obstack) symbol; *typedef_sym = *sym; SYMBOL_ACLASS_INDEX (typedef_sym) = LOC_TYPEDEF; SYMBOL_VALUE (typedef_sym) = valu; SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN; - if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) - TYPE_NAME (SYMBOL_TYPE (sym)) - = obconcat (&objfile->objfile_obstack, - SYMBOL_LINKAGE_NAME (sym), - (char *) NULL); + if (SYMBOL_TYPE (sym)->name () == 0) + SYMBOL_TYPE (sym)->set_name + (obconcat (&objfile->objfile_obstack, sym->linkage_name (), + (char *) NULL)); add_symbol_to_list (typedef_sym, get_file_symbols ()); } break; @@ -1380,23 +1366,21 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, /* Static symbol of local scope. */ SYMBOL_TYPE (sym) = read_type (&p, objfile); SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC; - SYMBOL_VALUE_ADDRESS (sym) = valu; + SET_SYMBOL_VALUE_ADDRESS (sym, valu); if (gdbarch_static_transform_name_p (gdbarch) - && gdbarch_static_transform_name (gdbarch, - SYMBOL_LINKAGE_NAME (sym)) - != SYMBOL_LINKAGE_NAME (sym)) + && gdbarch_static_transform_name (gdbarch, sym->linkage_name ()) + != sym->linkage_name ()) { struct bound_minimal_symbol msym; - msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), - NULL, objfile); + msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile); if (msym.minsym != NULL) { const char *new_name = gdbarch_static_transform_name - (gdbarch, SYMBOL_LINKAGE_NAME (sym)); + (gdbarch, sym->linkage_name ()); - SYMBOL_SET_LINKAGE_NAME (sym, new_name); - SYMBOL_VALUE_ADDRESS (sym) = BMSYMBOL_VALUE_ADDRESS (msym); + sym->set_linkage_name (new_name); + SET_SYMBOL_VALUE_ADDRESS (sym, BMSYMBOL_VALUE_ADDRESS (msym)); } } SYMBOL_DOMAIN (sym) = VAR_DOMAIN; @@ -1563,7 +1547,7 @@ read_type (const char **pp, struct objfile *objfile) /* If this is a forward reference, arrange to complain if it doesn't get patched up by the time we're done reading. */ - if (TYPE_CODE (type) == TYPE_CODE_UNDEF) + if (type->code () == TYPE_CODE_UNDEF) add_undefined_type (type, typenums); return type; @@ -1652,14 +1636,10 @@ again: memcpy (name, *pp, p - *pp); name[p - *pp] = '\0'; - std::string new_name = cp_canonicalize_string (name); - if (!new_name.empty ()) - { - type_name - = (char *) obstack_copy0 (&objfile->objfile_obstack, - new_name.c_str (), - new_name.length ()); - } + gdb::unique_xmalloc_ptr new_name = cp_canonicalize_string (name); + if (new_name != nullptr) + type_name = obstack_strdup (&objfile->objfile_obstack, + new_name.get ()); } if (type_name == NULL) { @@ -1689,8 +1669,8 @@ again: if (SYMBOL_CLASS (sym) == LOC_TYPEDEF && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN - && (TYPE_CODE (SYMBOL_TYPE (sym)) == code) - && strcmp (SYMBOL_LINKAGE_NAME (sym), type_name) == 0) + && (SYMBOL_TYPE (sym)->code () == code) + && strcmp (sym->linkage_name (), type_name) == 0) { obstack_free (&objfile->objfile_obstack, type_name); type = SYMBOL_TYPE (sym); @@ -1706,8 +1686,8 @@ again: fill in the rest of the fields when we get the full type. */ type = dbx_alloc_type (typenums, objfile); - TYPE_CODE (type) = code; - TYPE_NAME (type) = type_name; + type->set_code (code); + type->set_name (type_name); INIT_CPLUS_SPECIFIC (type); TYPE_STUB (type) = 1; @@ -1735,14 +1715,14 @@ again: /* Allocate and enter the typedef type first. This handles recursive types. */ type = dbx_alloc_type (typenums, objfile); - TYPE_CODE (type) = TYPE_CODE_TYPEDEF; + type->set_code (TYPE_CODE_TYPEDEF); { struct type *xtype = read_type (pp, objfile); if (type == xtype) { /* It's being defined as itself. That means it is "void". */ - TYPE_CODE (type) = TYPE_CODE_VOID; + type->set_code (TYPE_CODE_VOID); TYPE_LENGTH (type) = 1; } else if (type_size >= 0 || is_string) @@ -1771,7 +1751,7 @@ again: "complete_this_type" function, but never create unnecessary copies of a type otherwise. */ replace_type (type, xtype); - TYPE_NAME (type) = NULL; + type->set_name (NULL); } else { @@ -1854,13 +1834,13 @@ again: that's just an empty argument list. */ if (arg_types && ! arg_types->next - && TYPE_CODE (arg_types->type) == TYPE_CODE_VOID) + && arg_types->type->code () == TYPE_CODE_VOID) num_args = 0; - TYPE_FIELDS (func_type) - = (struct field *) TYPE_ALLOC (func_type, - num_args * sizeof (struct field)); - memset (TYPE_FIELDS (func_type), 0, num_args * sizeof (struct field)); + func_type->set_fields + ((struct field *) TYPE_ALLOC (func_type, + num_args * sizeof (struct field))); + memset (func_type->fields (), 0, num_args * sizeof (struct field)); { int i; struct type_list *t; @@ -1871,7 +1851,7 @@ again: for (t = arg_types, i = num_args - 1; t; t = t->next, i--) TYPE_FIELD_TYPE (func_type, i) = t->type; } - TYPE_NFIELDS (func_type) = num_args; + func_type->set_num_fields (num_args); TYPE_PROTOTYPED (func_type) = 1; type = func_type; @@ -2041,14 +2021,14 @@ again: type = dbx_alloc_type (typenums, objfile); type = read_array_type (pp, type, objfile); if (is_string) - TYPE_CODE (type) = TYPE_CODE_STRING; + type->set_code (TYPE_CODE_STRING); if (is_vector) make_vector_type (type); break; 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; @@ -2205,12 +2185,12 @@ rs6000_builtin_type (int typenum, struct objfile *objfile) break; case 25: /* Complex type consisting of two IEEE single precision values. */ - rettype = init_complex_type (objfile, "complex", + rettype = init_complex_type ("complex", rs6000_builtin_type (12, objfile)); break; case 26: /* Complex type consisting of two IEEE double precision values. */ - rettype = init_complex_type (objfile, "double complex", + rettype = init_complex_type ("double complex", rs6000_builtin_type (13, objfile)); break; case 27: @@ -2388,10 +2368,10 @@ read_member_functions (struct stab_field_info *fip, const char **pp, } /* These are methods, not functions. */ - if (TYPE_CODE (new_sublist->fn_field.type) == TYPE_CODE_FUNC) - TYPE_CODE (new_sublist->fn_field.type) = TYPE_CODE_METHOD; + if (new_sublist->fn_field.type->code () == TYPE_CODE_FUNC) + new_sublist->fn_field.type->set_code (TYPE_CODE_METHOD); else - gdb_assert (TYPE_CODE (new_sublist->fn_field.type) + gdb_assert (new_sublist->fn_field.type->code () == TYPE_CODE_METHOD); /* If this is just a stub, then we don't have the real name here. */ @@ -2769,7 +2749,7 @@ read_cpp_abbrev (struct stab_field_info *fip, const char **pp, switch (cpp_abbrev) { case 'f': /* $vf -- a virtual function table pointer */ - name = TYPE_NAME (context); + name = context->name (); if (name == NULL) { name = ""; @@ -2779,7 +2759,7 @@ read_cpp_abbrev (struct stab_field_info *fip, const char **pp, break; case 'b': /* $vb -- a virtual bsomethingorother */ - name = TYPE_NAME (context); + name = context->name (); if (name == NULL) { complaint (_("C++ abbreviated type name " @@ -2842,10 +2822,10 @@ 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); + struct gdbarch *gdbarch = objfile->arch (); fip->list->field.name - = (const char *) obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp); + = obstack_strndup (&objfile->objfile_obstack, *pp, p - *pp); *pp = p + 1; /* This means we have a visibility for a field coming. */ @@ -2939,16 +2919,16 @@ read_one_struct_field (struct stab_field_info *fip, const char **pp, struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field)); - if (TYPE_CODE (field_type) != TYPE_CODE_INT - && TYPE_CODE (field_type) != TYPE_CODE_RANGE - && TYPE_CODE (field_type) != TYPE_CODE_BOOL - && TYPE_CODE (field_type) != TYPE_CODE_ENUM) + if (field_type->code () != TYPE_CODE_INT + && field_type->code () != TYPE_CODE_RANGE + && field_type->code () != TYPE_CODE_BOOL + && field_type->code () != TYPE_CODE_ENUM) { FIELD_BITSIZE (fip->list->field) = 0; } if ((FIELD_BITSIZE (fip->list->field) == TARGET_CHAR_BIT * TYPE_LENGTH (field_type) - || (TYPE_CODE (field_type) == TYPE_CODE_ENUM + || (field_type->code () == TYPE_CODE_ENUM && FIELD_BITSIZE (fip->list->field) == gdbarch_int_bit (gdbarch)) ) @@ -3182,7 +3162,7 @@ read_baseclasses (struct stab_field_info *fip, const char **pp, field's name. */ newobj->field.type = read_type (pp, objfile); - newobj->field.name = TYPE_NAME (newobj->field.type); + newobj->field.name = newobj->field.type->name (); /* Skip trailing ';' and bump count of number of fields seen. */ if (**pp == ';') @@ -3253,7 +3233,7 @@ read_tilde_fields (struct stab_field_info *fip, const char **pp, set_type_vptr_basetype (type, t); if (type == t) /* Our own class provides vtbl ptr. */ { - for (i = TYPE_NFIELDS (t) - 1; + for (i = t->num_fields () - 1; i >= TYPE_N_BASECLASSES (t); --i) { @@ -3269,7 +3249,7 @@ read_tilde_fields (struct stab_field_info *fip, const char **pp, /* Virtual function table field not found. */ complaint (_("virtual function table pointer " "not found when defining class `%s'"), - TYPE_NAME (type)); + type->name ()); return 0; } else @@ -3329,10 +3309,11 @@ attach_fields_to_type (struct stab_field_info *fip, struct type *type, non-public fields. Record the field count, allocate space for the array of fields, and create blank visibility bitfields if necessary. */ - TYPE_NFIELDS (type) = nfields; - TYPE_FIELDS (type) = (struct field *) - TYPE_ALLOC (type, sizeof (struct field) * nfields); - memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields); + type->set_num_fields (nfields); + type->set_fields + ((struct field *) + TYPE_ALLOC (type, sizeof (struct field) * nfields)); + memset (type->fields (), 0, sizeof (struct field) * nfields); if (non_public_fields) { @@ -3358,7 +3339,7 @@ attach_fields_to_type (struct stab_field_info *fip, struct type *type, while (nfields-- > 0) { - TYPE_FIELD (type, nfields) = fip->list->field; + type->field (nfields) = fip->list->field; switch (fip->list->visibility) { case VISIBILITY_PRIVATE: @@ -3398,10 +3379,10 @@ complain_about_struct_wipeout (struct type *type) const char *name = ""; const char *kind = ""; - if (TYPE_NAME (type)) + if (type->name ()) { - name = TYPE_NAME (type); - switch (TYPE_CODE (type)) + name = type->name (); + switch (type->code ()) { case TYPE_CODE_STRUCT: kind = "struct "; break; case TYPE_CODE_UNION: kind = "union "; break; @@ -3486,7 +3467,7 @@ read_struct_type (const char **pp, struct type *type, enum type_code type_code, Obviously, GDB can't fix this by itself, but it can at least avoid scribbling on existing structure type objects when new definitions appear. */ - if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF + if (! (type->code () == TYPE_CODE_UNDEF || TYPE_STUB (type))) { complain_about_struct_wipeout (type); @@ -3496,7 +3477,7 @@ read_struct_type (const char **pp, struct type *type, enum type_code type_code, } INIT_CPLUS_SPECIFIC (type); - TYPE_CODE (type) = type_code; + type->set_code (type_code); TYPE_STUB (type) = 0; /* First comes the total size in bytes. */ @@ -3585,7 +3566,7 @@ read_array_type (const char **pp, struct type *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; @@ -3600,7 +3581,7 @@ static struct type * read_enum_type (const char **pp, struct type *type, struct objfile *objfile) { - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); const char *p; char *name; long n; @@ -3645,16 +3626,16 @@ read_enum_type (const char **pp, struct type *type, p = *pp; while (*p != ':') p++; - name = (char *) obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp); + name = obstack_strndup (&objfile->objfile_obstack, *pp, p - *pp); *pp = p + 1; n = read_huge_number (pp, ',', &nbits, 0); if (nbits != 0) return error_type (pp, objfile); - sym = allocate_symbol (objfile); - SYMBOL_SET_LINKAGE_NAME (sym, name); - SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language, - &objfile->objfile_obstack); + sym = new (&objfile->objfile_obstack) symbol; + sym->set_linkage_name (name); + sym->set_language (get_current_subfile ()->language, + &objfile->objfile_obstack); SYMBOL_ACLASS_INDEX (sym) = LOC_CONST; SYMBOL_DOMAIN (sym) = VAR_DOMAIN; SYMBOL_VALUE (sym) = n; @@ -3671,14 +3652,15 @@ read_enum_type (const char **pp, struct type *type, TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT; set_length_in_type_chain (type); - TYPE_CODE (type) = TYPE_CODE_ENUM; + type->set_code (TYPE_CODE_ENUM); TYPE_STUB (type) = 0; if (unsigned_enum) TYPE_UNSIGNED (type) = 1; - TYPE_NFIELDS (type) = nsyms; - TYPE_FIELDS (type) = (struct field *) - TYPE_ALLOC (type, sizeof (struct field) * nsyms); - memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms); + type->set_num_fields (nsyms); + type->set_fields + ((struct field *) + TYPE_ALLOC (type, sizeof (struct field) * nsyms)); + memset (type->fields (), 0, sizeof (struct field) * nsyms); /* Find the symbols for the values and put them into the type. The symbols can be found in the symlist that we put them on @@ -3698,8 +3680,8 @@ read_enum_type (const char **pp, struct type *type, struct symbol *xsym = syms->symbol[j]; SYMBOL_TYPE (xsym) = type; - TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym); - SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym)); + TYPE_FIELD_NAME (type, n) = xsym->linkage_name (); + SET_FIELD_ENUMVAL (type->field (n), SYMBOL_VALUE (xsym)); TYPE_FIELD_BITSIZE (type, n) = 0; } if (syms == osyms) @@ -3824,7 +3806,7 @@ read_sun_floating_type (const char **pp, int typenums[2], || details == NF_COMPLEX32) { rettype = dbx_init_float_type (objfile, nbits / 2); - return init_complex_type (objfile, NULL, rettype); + return init_complex_type (NULL, rettype); } return dbx_init_float_type (objfile, nbits); @@ -3897,7 +3879,7 @@ read_huge_number (const char **pp, int end, int *bits, && len == twos_complement_bits / 3)) { /* Ok, we have enough characters for a signed value, check - for signness by testing if the sign bit is set. */ + for signedness by testing if the sign bit is set. */ sign_bit = (twos_complement_bits % 3 + 2) % 3; c = *p - '0'; if (c & (1 << sign_bit)) @@ -4016,7 +3998,7 @@ static struct type * read_range_type (const char **pp, int typenums[2], int type_size, struct objfile *objfile) { - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); const char *orig_pp = *pp; int rangenums[2]; long n2, n3; @@ -4118,7 +4100,7 @@ read_range_type (const char **pp, int typenums[2], int type_size, = dbx_init_float_type (objfile, n2 * TARGET_CHAR_BIT); if (self_subrange) - return init_complex_type (objfile, NULL, float_type); + return init_complex_type (NULL, float_type); else return float_type; } @@ -4212,7 +4194,7 @@ handle_true_range: } 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); } @@ -4250,7 +4232,7 @@ read_args (const char **pp, int end, struct objfile *objfile, int *nargsp, complaint (_("Invalid (empty) method arguments")); *varargsp = 0; } - else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID) + else if (types[n - 1]->code () != TYPE_CODE_VOID) *varargsp = 1; else { @@ -4293,8 +4275,7 @@ common_block_start (const char *name, struct objfile *objfile) } 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)); + common_block_name = obstack_strdup (&objfile->objfile_obstack, name); } /* Process a N_ECOMM symbol. */ @@ -4319,9 +4300,9 @@ common_block_end (struct objfile *objfile) return; } - sym = allocate_symbol (objfile); + sym = new (&objfile->objfile_obstack) symbol; /* Note: common_block_name already saved on objfile_obstack. */ - SYMBOL_SET_LINKAGE_NAME (sym, common_block_name); + sym->set_linkage_name (common_block_name); SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK; /* Now we copy all the symbols which have been defined since the BCOMM. */ @@ -4348,7 +4329,7 @@ common_block_end (struct objfile *objfile) /* Should we be putting local_symbols back to what it was? Does it matter? */ - i = hashname (SYMBOL_LINKAGE_NAME (sym)); + i = hashname (sym->linkage_name ()); SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i]; global_sym_chain[i] = sym; common_block_name = NULL; @@ -4368,7 +4349,9 @@ fix_common_block (struct symbol *sym, CORE_ADDR valu) int j; for (j = next->nsyms - 1; j >= 0; j--) - SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu; + SET_SYMBOL_VALUE_ADDRESS (next->symbol[j], + SYMBOL_VALUE_ADDRESS (next->symbol[j]) + + valu); } } @@ -4428,7 +4411,7 @@ add_undefined_type_1 (struct type *type) static void add_undefined_type (struct type *type, int typenums[2]) { - if (TYPE_NAME (type) == NULL) + if (type->name () == NULL) add_undefined_type_noname (type, typenums); else add_undefined_type_1 (type); @@ -4447,7 +4430,7 @@ cleanup_undefined_types_noname (struct objfile *objfile) struct type **type; type = dbx_lookup_type (nat.typenums, objfile); - if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF) + if (nat.type != *type && (*type)->code () != TYPE_CODE_UNDEF) { /* The instance flags of the undefined type are still unset, and needs to be copied over from the reference type. @@ -4497,7 +4480,7 @@ cleanup_undefined_types_1 (void) for (type = undef_types; type < undef_types + undef_types_length; type++) { - switch (TYPE_CODE (*type)) + switch ((*type)->code ()) { case TYPE_CODE_STRUCT: @@ -4513,7 +4496,7 @@ cleanup_undefined_types_1 (void) struct pending *ppt; int i; /* Name of the type, without "struct" or "union". */ - const char *type_name = TYPE_NAME (*type); + const char *type_name = (*type)->name (); if (type_name == NULL) { @@ -4528,12 +4511,11 @@ cleanup_undefined_types_1 (void) if (SYMBOL_CLASS (sym) == LOC_TYPEDEF && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN - && (TYPE_CODE (SYMBOL_TYPE (sym)) == - TYPE_CODE (*type)) + && (SYMBOL_TYPE (sym)->code () == + (*type)->code ()) && (TYPE_INSTANCE_FLAGS (*type) == TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym))) - && strcmp (SYMBOL_LINKAGE_NAME (sym), - type_name) == 0) + && strcmp (sym->linkage_name (), type_name) == 0) replace_type (*type, SYMBOL_TYPE (sym)); } } @@ -4545,7 +4527,7 @@ cleanup_undefined_types_1 (void) { complaint (_("forward-referenced types left unresolved, " "type code %d."), - TYPE_CODE (*type)); + (*type)->code ()); } break; } @@ -4554,7 +4536,7 @@ cleanup_undefined_types_1 (void) undef_types_length = 0; } -/* Try to fix all the undefined types we ecountered while processing +/* Try to fix all the undefined types we encountered while processing this unit. */ void @@ -4615,12 +4597,11 @@ scan_file_globals (struct objfile *objfile) /* Get the hash index and check all the symbols under that hash index. */ - hash = hashname (MSYMBOL_LINKAGE_NAME (msymbol)); + hash = hashname (msymbol->linkage_name ()); for (sym = global_sym_chain[hash]; sym;) { - if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol), - SYMBOL_LINKAGE_NAME (sym)) == 0) + if (strcmp (msymbol->linkage_name (), sym->linkage_name ()) == 0) { /* Splice this symbol out of the hash chain and assign the value we have to it. */ @@ -4646,8 +4627,9 @@ scan_file_globals (struct objfile *objfile) } else { - SYMBOL_VALUE_ADDRESS (sym) - = MSYMBOL_VALUE_ADDRESS (resolve_objfile, msymbol); + SET_SYMBOL_VALUE_ADDRESS + (sym, MSYMBOL_VALUE_ADDRESS (resolve_objfile, + msymbol)); } SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol); } @@ -4685,7 +4667,7 @@ scan_file_globals (struct objfile *objfile) /* Change the symbol address from the misleading chain value to address zero. */ - SYMBOL_VALUE_ADDRESS (prev) = 0; + SET_SYMBOL_VALUE_ADDRESS (prev, 0); /* Complain about unresolved common block symbols. */ if (SYMBOL_CLASS (prev) == LOC_STATIC) @@ -4693,7 +4675,7 @@ scan_file_globals (struct objfile *objfile) else complaint (_("%s: common block `%s' from " "global_sym_chain unresolved"), - objfile_name (objfile), SYMBOL_PRINT_NAME (prev)); + objfile_name (objfile), prev->print_name ()); } } memset (global_sym_chain, 0, sizeof (global_sym_chain)); @@ -4793,13 +4775,14 @@ find_name_end (const char *name) int hashname (const char *name) { - return hash (name, strlen (name)) % HASHSIZE; + return fast_hash (name, strlen (name)) % HASHSIZE; } /* Initializer for this module. */ +void _initialize_stabsread (); void -_initialize_stabsread (void) +_initialize_stabsread () { undef_types_allocated = 20; undef_types_length = 0;