]> Git Repo - binutils.git/commitdiff
gdb: remove SYMBOL_TYPE macro
authorSimon Marchi <[email protected]>
Fri, 28 Jan 2022 03:16:41 +0000 (22:16 -0500)
committerSimon Marchi <[email protected]>
Sun, 6 Feb 2022 21:03:47 +0000 (16:03 -0500)
Add a getter and a setter for a symbol's type.  Remove the corresponding
macro and adjust all callers.

Change-Id: Ie1a137744c5bfe1df4d4f9ae5541c5299577c8de

57 files changed:
gdb/ada-exp.y
gdb/ada-lang.c
gdb/ada-tasks.c
gdb/ax-gdb.c
gdb/block.c
gdb/blockframe.c
gdb/buildsym.c
gdb/c-exp.y
gdb/c-typeprint.c
gdb/c-valprint.c
gdb/coffread.c
gdb/compile/compile-c-symbols.c
gdb/compile/compile-cplus-symbols.c
gdb/compile/compile-cplus-types.c
gdb/compile/compile-object-load.c
gdb/compile/compile-object-run.c
gdb/cp-namespace.c
gdb/cp-support.c
gdb/ctfread.c
gdb/d-exp.y
gdb/d-namespace.c
gdb/dwarf2/loc.c
gdb/dwarf2/read.c
gdb/eval.c
gdb/f-exp.y
gdb/fbsd-tdep.c
gdb/findvar.c
gdb/gdbtypes.c
gdb/gnu-v3-abi.c
gdb/go-exp.y
gdb/guile/scm-symbol.c
gdb/infcmd.c
gdb/jit.c
gdb/language.c
gdb/linespec.c
gdb/m2-typeprint.c
gdb/mdebugread.c
gdb/mi/mi-cmd-stack.c
gdb/mi/mi-symbol-cmds.c
gdb/objc-lang.c
gdb/p-exp.y
gdb/p-valprint.c
gdb/python/py-finishbreakpoint.c
gdb/python/py-symbol.c
gdb/python/py-type.c
gdb/rust-lang.c
gdb/rust-parse.c
gdb/sparc-tdep.c
gdb/stabsread.c
gdb/stack.c
gdb/symmisc.c
gdb/symtab.c
gdb/symtab.h
gdb/tracepoint.c
gdb/typeprint.c
gdb/valops.c
gdb/xcoffread.c

index 0cb4aac10e33873bd57c3549e18bf39886969005..916b8ef94fef99f5a931e9fcf33b0d52236b00c1 100644 (file)
@@ -1332,10 +1332,10 @@ select_possible_type_sym (const std::vector<struct block_symbol> &syms)
     switch (syms[i].symbol->aclass ())
       {
       case LOC_TYPEDEF:
-       if (ada_prefer_type (SYMBOL_TYPE (syms[i].symbol), preferred_type))
+       if (ada_prefer_type (syms[i].symbol->type (), preferred_type))
          {
            preferred_index = i;
-           preferred_type = SYMBOL_TYPE (syms[i].symbol);
+           preferred_type = syms[i].symbol->type ();
          }
        break;
       case LOC_REGISTER:
@@ -1374,7 +1374,7 @@ find_primitive_type (struct parser_state *par_state, const char *name)
       strcat (expanded_name, name);
       sym = ada_lookup_symbol (expanded_name, NULL, VAR_DOMAIN).symbol;
       if (sym != NULL && sym->aclass () == LOC_TYPEDEF)
-       type = SYMBOL_TYPE (sym);
+       type = sym->type ();
     }
 
   return type;
@@ -1474,7 +1474,7 @@ get_symbol_field_type (struct symbol *sym, const char *encoded_field_name)
 {
   const char *field_name = encoded_field_name;
   const char *subfield_name;
-  struct type *type = SYMBOL_TYPE (sym);
+  struct type *type = sym->type ();
   int fieldno;
 
   if (type == NULL || field_name == NULL)
@@ -1595,7 +1595,7 @@ write_var_or_type (struct parser_state *par_state,
              struct type *field_type;
              
              if (tail_index == name_len)
-               return SYMBOL_TYPE (type_sym);
+               return type_sym->type ();
 
              /* We have some extraneous characters after the type name.
                 If this is an expression "TYPE_NAME.FIELD0.[...].FIELDN",
index 636ae906250bbc124ddfbfbde46e48476998f36a..fbeb176d5668152d12c5fae4ac8e9e8792c9c386 100644 (file)
@@ -3163,7 +3163,7 @@ static void
 ada_print_symbol_signature (struct ui_file *stream, struct symbol *sym,
                            const struct type_print_options *flags)
 {
-  struct type *type = SYMBOL_TYPE (sym);
+  struct type *type = sym->type ();
 
   fprintf_filtered (stream, "%s", sym->print_name ());
   if (!print_signatures
@@ -3348,8 +3348,8 @@ See set/show multiple-symbol."));
        {
          int is_enumeral =
            (syms[i].symbol->aclass () == LOC_CONST
-            && SYMBOL_TYPE (syms[i].symbol) != NULL
-            && SYMBOL_TYPE (syms[i].symbol)->code () == TYPE_CODE_ENUM);
+            && syms[i].symbol->type () != NULL
+            && syms[i].symbol->type ()->code () == TYPE_CODE_ENUM);
          struct symtab *symtab = NULL;
 
          if (syms[i].symbol->is_objfile_owned ())
@@ -3365,10 +3365,10 @@ See set/show multiple-symbol."));
                               SYMBOL_LINE (syms[i].symbol));
            }
          else if (is_enumeral
-                  && SYMBOL_TYPE (syms[i].symbol)->name () != NULL)
+                  && syms[i].symbol->type ()->name () != NULL)
            {
              printf_filtered (("[%d] "), i + first_choice);
-             ada_print_type (SYMBOL_TYPE (syms[i].symbol), NULL,
+             ada_print_type (syms[i].symbol->type (), NULL,
                              gdb_stdout, -1, 0, &type_print_raw_options);
              printf_filtered (_("'(%s) (enumeral)\n"),
                               syms[i].symbol->print_name ());
@@ -3467,7 +3467,7 @@ ada_resolve_enum (std::vector<struct block_symbol> &syms,
     {
       /* We already know the name matches, so we're just looking for
         an element of the correct enum type.  */
-      if (ada_check_typedef (SYMBOL_TYPE (syms[i].symbol)) == context_type)
+      if (ada_check_typedef (syms[i].symbol->type ()) == context_type)
        return i;
     }
 
@@ -3626,7 +3626,7 @@ static int
 ada_args_match (struct symbol *func, struct value **actuals, int n_actuals)
 {
   int i;
-  struct type *func_type = SYMBOL_TYPE (func);
+  struct type *func_type = func->type ();
 
   if (func->aclass () == LOC_CONST
       && func_type->code () == TYPE_CODE_ENUM)
@@ -3714,7 +3714,7 @@ ada_resolve_function (std::vector<struct block_symbol> &syms,
     {
       for (k = 0; k < syms.size (); k += 1)
        {
-         struct type *type = ada_check_typedef (SYMBOL_TYPE (syms[k].symbol));
+         struct type *type = ada_check_typedef (syms[k].symbol->type ());
 
          if (ada_args_match (syms[k].symbol, args, nargs)
              && (fallback || return_match (type, context_type)))
@@ -4441,8 +4441,8 @@ static int
 is_nonfunction (const std::vector<struct block_symbol> &syms)
 {
   for (const block_symbol &sym : syms)
-    if (SYMBOL_TYPE (sym.symbol)->code () != TYPE_CODE_FUNC
-       && (SYMBOL_TYPE (sym.symbol)->code () != TYPE_CODE_ENUM
+    if (sym.symbol->type ()->code () != TYPE_CODE_FUNC
+       && (sym.symbol->type ()->code () != TYPE_CODE_ENUM
            || sym.symbol->aclass () != LOC_CONST))
       return 1;
 
@@ -4487,8 +4487,8 @@ lesseq_defined_than (struct symbol *sym0, struct symbol *sym1)
       return 1;
     case LOC_TYPEDEF:
       {
-       struct type *type0 = SYMBOL_TYPE (sym0);
-       struct type *type1 = SYMBOL_TYPE (sym1);
+       struct type *type0 = sym0->type ();
+       struct type *type1 = sym1->type ();
        const char *name0 = sym0->linkage_name ();
        const char *name1 = sym1->linkage_name ();
        int len0 = strlen (name0);
@@ -4501,7 +4501,7 @@ lesseq_defined_than (struct symbol *sym0, struct symbol *sym1)
       }
     case LOC_CONST:
       return SYMBOL_VALUE (sym0) == SYMBOL_VALUE (sym1)
-       && equiv_types (SYMBOL_TYPE (sym0), SYMBOL_TYPE (sym1));
+       && equiv_types (sym0->type (), sym1->type ());
 
     case LOC_STATIC:
       {
@@ -4675,7 +4675,7 @@ symbols_are_identical_enums (const std::vector<struct block_symbol> &syms)
 
   /* Quick check: All symbols should have an enum type.  */
   for (i = 0; i < syms.size (); i++)
-    if (SYMBOL_TYPE (syms[i].symbol)->code () != TYPE_CODE_ENUM)
+    if (syms[i].symbol->type ()->code () != TYPE_CODE_ENUM)
       return 0;
 
   /* Quick check: They should all have the same value.  */
@@ -4685,16 +4685,16 @@ symbols_are_identical_enums (const std::vector<struct block_symbol> &syms)
 
   /* Quick check: They should all have the same number of enumerals.  */
   for (i = 1; i < syms.size (); i++)
-    if (SYMBOL_TYPE (syms[i].symbol)->num_fields ()
-       != SYMBOL_TYPE (syms[0].symbol)->num_fields ())
+    if (syms[i].symbol->type ()->num_fields ()
+       != syms[0].symbol->type ()->num_fields ())
       return 0;
 
   /* All the sanity checks passed, so we might have a set of
      identical enumeration types.  Perform a more complete
      comparison of the type of each symbol.  */
   for (i = 1; i < syms.size (); i++)
-    if (!ada_identical_enum_types_p (SYMBOL_TYPE (syms[i].symbol),
-                                    SYMBOL_TYPE (syms[0].symbol)))
+    if (!ada_identical_enum_types_p (syms[i].symbol->type (),
+                                    syms[0].symbol->type ()))
       return 0;
 
   return 1;
@@ -4725,13 +4725,13 @@ remove_extra_symbols (std::vector<struct block_symbol> *syms)
       /* If two symbols have the same name and one of them is a stub type,
         the get rid of the stub.  */
 
-      if (SYMBOL_TYPE ((*syms)[i].symbol)->is_stub ()
+      if ((*syms)[i].symbol->type ()->is_stub ()
          && (*syms)[i].symbol->linkage_name () != NULL)
        {
          for (j = 0; j < syms->size (); j++)
            {
              if (j != i
-                 && !SYMBOL_TYPE ((*syms)[j].symbol)->is_stub ()
+                 && !(*syms)[j].symbol->type ()->is_stub ()
                  && (*syms)[j].symbol->linkage_name () != NULL
                  && strcmp ((*syms)[i].symbol->linkage_name (),
                             (*syms)[j].symbol->linkage_name ()) == 0)
@@ -4744,7 +4744,7 @@ remove_extra_symbols (std::vector<struct block_symbol> *syms)
 
       else if ((*syms)[i].symbol->linkage_name () != NULL
          && (*syms)[i].symbol->aclass () == LOC_STATIC
-         && is_nondebugging_type (SYMBOL_TYPE ((*syms)[i].symbol)))
+         && is_nondebugging_type ((*syms)[i].symbol->type ()))
        {
          for (j = 0; j < syms->size (); j += 1)
            {
@@ -4848,7 +4848,7 @@ old_renaming_is_invisible (const struct symbol *sym, const char *function_name)
   if (sym->aclass () != LOC_TYPEDEF)
     return 0;
 
-  std::string scope = xget_renaming_scope (SYMBOL_TYPE (sym));
+  std::string scope = xget_renaming_scope (sym->type ());
 
   /* If the rename has been defined in a package, then it is visible.  */
   if (is_package_name (scope.c_str ()))
@@ -7231,7 +7231,7 @@ ada_find_any_type (const char *name)
   struct symbol *sym = ada_find_any_type_symbol (name);
 
   if (sym != NULL)
-    return SYMBOL_TYPE (sym);
+    return sym->type ();
 
   return NULL;
 }
@@ -10420,7 +10420,7 @@ ada_var_value_operation::evaluate (struct type *expect_type,
 
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
-      struct type *type = static_unwrap_type (SYMBOL_TYPE (sym));
+      struct type *type = static_unwrap_type (sym->type ());
       /* Check to see if this is a tagged type.  We also need to handle
         the case where the type is a reference to a tagged type, but
         we have to be careful to exclude pointers to tagged types.
@@ -10511,7 +10511,7 @@ ada_var_value_operation::resolve (struct expression *exp,
     }
 
   if (deprocedure_p
-      && (SYMBOL_TYPE (std::get<0> (m_storage).symbol)->code ()
+      && (std::get<0> (m_storage).symbol->type ()->code ()
          == TYPE_CODE_FUNC))
     return true;
 
@@ -12418,7 +12418,7 @@ catch_assert_command (const char *arg_entry, int from_tty,
 static int
 ada_is_exception_sym (struct symbol *sym)
 {
-  const char *type_name = SYMBOL_TYPE (sym)->name ();
+  const char *type_name = sym->type ()->name ();
 
   return (sym->aclass () != LOC_TYPEDEF
          && sym->aclass () != LOC_BLOCK
index 5b602c4d36fbfc46d24d6df2571b23c6a8d90b10..6a41d5f4b2b5f3cec7eec81ddade5f1afced39d2 100644 (file)
@@ -503,7 +503,7 @@ ada_get_tcb_types_info (void)
     lookup_symbol_in_language (entry_call_record_name, NULL, STRUCT_DOMAIN,
                               language_c, NULL).symbol;
 
-  if (atcb_sym == NULL || atcb_sym->type == NULL)
+  if (atcb_sym == NULL || atcb_sym->type () == NULL)
     {
       /* In Ravenscar run-time libs, the  ATCB does not have a dynamic
         size, so the symbol name differs.  */
@@ -511,34 +511,34 @@ ada_get_tcb_types_info (void)
                                            STRUCT_DOMAIN, language_c,
                                            NULL).symbol;
 
-      if (atcb_sym == NULL || atcb_sym->type == NULL)
+      if (atcb_sym == NULL || atcb_sym->type () == NULL)
        return _("Cannot find Ada_Task_Control_Block type");
 
-      type = atcb_sym->type;
+      type = atcb_sym->type ();
     }
   else
     {
       /* Get a static representation of the type record
         Ada_Task_Control_Block.  */
-      type = atcb_sym->type;
+      type = atcb_sym->type ();
       type = ada_template_to_fixed_record_type_1 (type, NULL, 0, NULL, 0);
     }
 
-  if (common_atcb_sym == NULL || common_atcb_sym->type == NULL)
+  if (common_atcb_sym == NULL || common_atcb_sym->type () == NULL)
     return _("Cannot find Common_ATCB type");
-  if (private_data_sym == NULL || private_data_sym->type == NULL)
+  if (private_data_sym == NULL || private_data_sym->type ()== NULL)
     return _("Cannot find Private_Data type");
-  if (entry_call_record_sym == NULL || entry_call_record_sym->type == NULL)
+  if (entry_call_record_sym == NULL || entry_call_record_sym->type () == NULL)
     return _("Cannot find Entry_Call_Record type");
 
   /* Get the type for Ada_Task_Control_Block.Common.  */
-  common_type = common_atcb_sym->type;
+  common_type = common_atcb_sym->type ();
 
   /* Get the type for Ada_Task_Control_Bloc.Common.Call.LL.  */
-  ll_type = private_data_sym->type;
+  ll_type = private_data_sym->type ();
 
   /* Get the type for Common_ATCB.Call.all.  */
-  call_type = entry_call_record_sym->type;
+  call_type = entry_call_record_sym->type ();
 
   /* Get the field indices.  */
   fieldnos.common = ada_get_field_index (type, "common", 0);
@@ -904,7 +904,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
       if (sym != NULL)
        {
          /* Validate.  */
-         struct type *type = check_typedef (SYMBOL_TYPE (sym));
+         struct type *type = check_typedef (sym->type ());
          struct type *eltype = NULL;
          struct type *idxtype = NULL;
 
@@ -950,7 +950,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
       if (sym != NULL && SYMBOL_VALUE_ADDRESS (sym) != 0)
        {
          /* Validate.  */
-         struct type *type = check_typedef (SYMBOL_TYPE (sym));
+         struct type *type = check_typedef (sym->type ());
 
          if (type->code () == TYPE_CODE_PTR)
            {
index 7ba44c4c8c09972370da15f37c4146c1306329d8..0b12dc3a42f155915891c76a63fd9929057321f2 100644 (file)
@@ -510,7 +510,7 @@ static void
 gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
 {
   /* Dereference any typedefs.  */
-  value->type = check_typedef (SYMBOL_TYPE (var));
+  value->type = check_typedef (var->type ());
   value->optimized_out = 0;
 
   if (SYMBOL_COMPUTED_OPS (var) != NULL)
index 3d11ea607682f8c103d2946920844376ad3c8196..3fe096db583854377b662c7cfd42bc28c6b5043b 100644 (file)
@@ -857,7 +857,7 @@ block_find_symbol (const struct block *block, const char *name,
 int
 block_find_non_opaque_type (struct symbol *sym, void *data)
 {
-  return !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym));
+  return !TYPE_IS_OPAQUE (sym->type ());
 }
 
 /* See block.h.  */
@@ -867,7 +867,7 @@ block_find_non_opaque_type_preferred (struct symbol *sym, void *data)
 {
   struct symbol **best = (struct symbol **) data;
 
-  if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
+  if (!TYPE_IS_OPAQUE (sym->type ()))
     return 1;
   *best = sym;
   return 0;
index 88595d4fcb0b31cc097321d2fab16564618fa834..50c464f44a24c8931616daec07d3b0a9aec2e43a 100644 (file)
@@ -426,7 +426,7 @@ find_function_type (CORE_ADDR pc)
   struct symbol *sym = find_pc_function (pc);
 
   if (sym != NULL && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) == pc)
-    return SYMBOL_TYPE (sym);
+    return sym->type ();
 
   return NULL;
 }
index 51764a67040c58188fee49ba842f29492a61263b..999f632f4013f798addce123bd443f8b65688080 100644 (file)
@@ -249,7 +249,7 @@ buildsym_compunit::finish_block_internal
 
   if (symbol)
     {
-      struct type *ftype = SYMBOL_TYPE (symbol);
+      struct type *ftype = symbol->type ();
       struct mdict_iterator miter;
       SYMBOL_BLOCK_VALUE (symbol) = block;
       BLOCK_FUNCTION (block) = symbol;
@@ -286,7 +286,7 @@ buildsym_compunit::finish_block_internal
 
                  if (sym->is_argument ())
                    {
-                     ftype->field (iparams).set_type (SYMBOL_TYPE (sym));
+                     ftype->field (iparams).set_type (sym->type ());
                      TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
                      iparams++;
                    }
index 6d4cb475bd1996be2defa16cb71f835d6caed455..de29d2f70e239efe9437ef5b103ecaf16c18955d 100644 (file)
@@ -3090,7 +3090,7 @@ classify_name (struct parser_state *par_state, const struct block *block,
                                &inner_is_a_field_of_this);
          if (bsym.symbol != NULL)
            {
-             yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);
+             yylval.tsym.type = bsym.symbol->type ();
              return TYPENAME;
            }
        }
@@ -3118,7 +3118,7 @@ classify_name (struct parser_state *par_state, const struct block *block,
 
   if (bsym.symbol && bsym.symbol->aclass () == LOC_TYPEDEF)
     {
-      yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);
+      yylval.tsym.type = bsym.symbol->type ();
       return TYPENAME;
     }
 
@@ -3135,7 +3135,7 @@ classify_name (struct parser_state *par_state, const struct block *block,
          sym = lookup_struct_typedef (copy.c_str (),
                                       par_state->expression_context_block, 1);
          if (sym)
-           yylval.theclass.type = SYMBOL_TYPE (sym);
+           yylval.theclass.type = sym->type ();
          return CLASSNAME;
        }
     }
@@ -3231,7 +3231,7 @@ classify_inner_name (struct parser_state *par_state,
       return ERROR;
 
     case LOC_TYPEDEF:
-      yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
+      yylval.tsym.type = yylval.ssym.sym.symbol->type ();
       return TYPENAME;
 
     default:
index 14d671e2989772b5c3033bd6b1c0e90992cb435a..405ede8b9c88ae3aa0a30385c199f75de1e7743b 100644 (file)
@@ -207,10 +207,10 @@ c_print_typedef (struct type *type,
   type = check_typedef (type);
   fprintf_filtered (stream, "typedef ");
   type_print (type, "", stream, -1);
-  if ((SYMBOL_TYPE (new_symbol))->name () == 0
-      || strcmp ((SYMBOL_TYPE (new_symbol))->name (),
+  if ((new_symbol->type ())->name () == 0
+      || strcmp ((new_symbol->type ())->name (),
                 new_symbol->linkage_name ()) != 0
-      || SYMBOL_TYPE (new_symbol)->code () == TYPE_CODE_TYPEDEF)
+      || new_symbol->type ()->code () == TYPE_CODE_TYPEDEF)
     fprintf_filtered (stream, " %s", new_symbol->print_name ());
   fprintf_filtered (stream, ";");
 }
@@ -899,7 +899,7 @@ c_type_print_template_args (const struct type_print_options *flags,
          fprintf_filtered (stream, "%s = ", sym->linkage_name ());
        }
 
-      c_print_type (SYMBOL_TYPE (sym), "", stream, -1, 0, flags);
+      c_print_type (sym->type (), "", stream, -1, 0, flags);
     }
 
   if (!first)
index 461763075e87e7f8c4c57d5eb452c38cdaa4ac5f..fadbc5b7022ca5405869f174557739604041dc69 100644 (file)
@@ -210,7 +210,7 @@ print_unpacked_pointer (struct type *type, struct type *elttype,
 
          if (wsym)
            {
-             wtype = SYMBOL_TYPE (wsym);
+             wtype = wsym->type ();
            }
          else
            {
index e4db4fdb02f6cf0d49e7104b8f254a86101277de..3ff62bc96c0208dc9038ddc9a3b7ab189919b07f 100644 (file)
@@ -1492,8 +1492,8 @@ patch_opaque_types (struct symtab *s)
         from different files with the same name.  */
       if (real_sym->aclass () == LOC_TYPEDEF
          && real_sym->domain () == VAR_DOMAIN
-         && SYMBOL_TYPE (real_sym)->code () == TYPE_CODE_PTR
-         && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
+         && real_sym->type ()->code () == TYPE_CODE_PTR
+         && TYPE_LENGTH (TYPE_TARGET_TYPE (real_sym->type ())) != 0)
        {
          const char *name = real_sym->linkage_name ();
          int hash = hashname (name);
@@ -1514,7 +1514,7 @@ patch_opaque_types (struct symtab *s)
                      opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
                    }
 
-                 patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym));
+                 patch_type (sym->type (), real_sym->type ());
 
                  if (prev)
                    {
@@ -1571,9 +1571,9 @@ process_coff_symbol (struct coff_symbol *cs,
   if (ISFCN (cs->c_type))
     {
       SYMBOL_VALUE (sym) += objfile->text_section_offset ();
-      SYMBOL_TYPE (sym) =
-       lookup_function_type (decode_function_type (cs, cs->c_type,
-                                                   aux, objfile));
+      sym->set_type
+       (lookup_function_type (decode_function_type (cs, cs->c_type,
+                                                    aux, objfile)));
 
       sym->set_aclass_index (LOC_BLOCK);
       if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
@@ -1585,7 +1585,7 @@ process_coff_symbol (struct coff_symbol *cs,
     }
   else
     {
-      SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux, objfile);
+      sym->set_type (decode_type (cs, cs->c_type, aux, objfile));
       switch (cs->c_sclass)
        {
        case C_NULL:
@@ -1656,10 +1656,10 @@ process_coff_symbol (struct coff_symbol *cs,
          sym->set_domain (VAR_DOMAIN);
 
          /* If type has no name, give it one.  */
-         if (SYMBOL_TYPE (sym)->name () == 0)
+         if (sym->type ()->name () == 0)
            {
-             if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR
-                 || SYMBOL_TYPE (sym)->code () == TYPE_CODE_FUNC)
+             if (sym->type ()->code () == TYPE_CODE_PTR
+                 || sym->type ()->code () == TYPE_CODE_FUNC)
                {
                  /* If we are giving a name to a type such as
                     "pointer to foo" or "function returning foo", we
@@ -1682,7 +1682,7 @@ process_coff_symbol (struct coff_symbol *cs,
                  ;
                }
              else
-               SYMBOL_TYPE (sym)->set_name (xstrdup (sym->linkage_name ()));
+               sym->type ()->set_name (xstrdup (sym->linkage_name ()));
            }
 
          /* Keep track of any type which points to empty structured
@@ -1691,9 +1691,9 @@ process_coff_symbol (struct coff_symbol *cs,
             not an empty structured type, though; the forward
             references work themselves out via the magic of
             coff_lookup_type.  */
-         if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR
-             && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0
-             && TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))->code ()
+         if (sym->type ()->code () == TYPE_CODE_PTR
+             && TYPE_LENGTH (TYPE_TARGET_TYPE (sym->type ())) == 0
+             && TYPE_TARGET_TYPE (sym->type ())->code ()
              != TYPE_CODE_UNDEF)
            {
              int i = hashname (sym->linkage_name ());
@@ -1713,11 +1713,11 @@ process_coff_symbol (struct coff_symbol *cs,
          /* Some compilers try to be helpful by inventing "fake"
             names for anonymous enums, structures, and unions, like
             "~0fake" or ".0fake".  Thanks, but no thanks...  */
-         if (SYMBOL_TYPE (sym)->name () == 0)
+         if (sym->type ()->name () == 0)
            if (sym->linkage_name () != NULL
                && *sym->linkage_name () != '~'
                && *sym->linkage_name () != '.')
-             SYMBOL_TYPE (sym)->set_name (xstrdup (sym->linkage_name ()));
+             sym->type ()->set_name (xstrdup (sym->linkage_name ()));
 
          add_symbol_to_list (sym, get_file_symbols ());
          break;
@@ -2143,7 +2143,7 @@ coff_read_enum_type (int index, int length, int lastsym,
        {
          struct symbol *xsym = syms->symbol[j];
 
-         SYMBOL_TYPE (xsym) = type;
+         xsym->set_type (type);
          type->field (n).set_name (xsym->linkage_name ());
          type->field (n).set_loc_enumval (SYMBOL_VALUE (xsym));
          if (SYMBOL_VALUE (xsym) < 0)
index 41746c20e057169de0eeb4e9436fb9209911ebb3..4f7a5b22da51251cd8cd90f4506c4f1eeeb12b32 100644 (file)
@@ -65,7 +65,7 @@ convert_one_symbol (compile_c_instance *context,
   if (sym.symbol->aclass () == LOC_LABEL)
     sym_type = 0;
   else
-    sym_type = context->convert_type (SYMBOL_TYPE (sym.symbol));
+    sym_type = context->convert_type (sym.symbol->type ());
 
   if (sym.symbol->domain () == STRUCT_DOMAIN)
     {
@@ -94,12 +94,12 @@ convert_one_symbol (compile_c_instance *context,
        case LOC_BLOCK:
          kind = GCC_C_SYMBOL_FUNCTION;
          addr = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym.symbol));
-         if (is_global && SYMBOL_TYPE (sym.symbol)->is_gnu_ifunc ())
+         if (is_global && sym.symbol->type ()->is_gnu_ifunc ())
            addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
          break;
 
        case LOC_CONST:
-         if (SYMBOL_TYPE (sym.symbol)->code () == TYPE_CODE_ENUM)
+         if (sym.symbol->type ()->code () == TYPE_CODE_ENUM)
            {
              /* Already handled by convert_enum.  */
              return;
@@ -405,7 +405,7 @@ gcc_symbol_address (void *datum, struct gcc_c_context *gcc_context,
                                "gcc_symbol_address \"%s\": full symbol\n",
                                identifier);
          result = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
-         if (SYMBOL_TYPE (sym)->is_gnu_ifunc ())
+         if (sym->type ()->is_gnu_ifunc ())
            result = gnu_ifunc_resolve_addr (target_gdbarch (), result);
          found = 1;
        }
@@ -548,14 +548,14 @@ generate_c_for_for_one_variable (compile_instance *compiler,
 
   try
     {
-      if (is_dynamic_type (SYMBOL_TYPE (sym)))
+      if (is_dynamic_type (sym->type ()))
        {
          /* We need to emit to a temporary buffer in case an error
             occurs in the middle.  */
          string_file local_file;
 
          generate_vla_size (compiler, &local_file, gdbarch, registers_used, pc,
-                            SYMBOL_TYPE (sym), sym);
+                            sym->type (), sym);
 
          stream->write (local_file.c_str (), local_file.size ());
        }
index 3a24aa7dc8b00bc456e3872d7a1c73df2435529b..7cf5703dc71d5024eb39814edab2e040564ae882 100644 (file)
@@ -56,7 +56,7 @@ convert_one_symbol (compile_cplus_instance *instance,
   if (sym.symbol->aclass () == LOC_LABEL)
     sym_type = 0;
   else
-    sym_type = instance->convert_type (SYMBOL_TYPE (sym.symbol));
+    sym_type = instance->convert_type (sym.symbol->type ());
 
   if (sym.symbol->domain () == STRUCT_DOMAIN)
     {
@@ -73,9 +73,9 @@ convert_one_symbol (compile_cplus_instance *instance,
       switch (sym.symbol->aclass ())
        {
        case LOC_TYPEDEF:
-         if (SYMBOL_TYPE (sym.symbol)->code () == TYPE_CODE_TYPEDEF)
+         if (sym.symbol->type ()->code () == TYPE_CODE_TYPEDEF)
            kind = GCC_CP_SYMBOL_TYPEDEF;
-         else  if (SYMBOL_TYPE (sym.symbol)->code () == TYPE_CODE_NAMESPACE)
+         else  if (sym.symbol->type ()->code () == TYPE_CODE_NAMESPACE)
            return;
          break;
 
@@ -88,13 +88,13 @@ convert_one_symbol (compile_cplus_instance *instance,
          {
            kind = GCC_CP_SYMBOL_FUNCTION;
            addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym.symbol));
-           if (is_global && SYMBOL_TYPE (sym.symbol)->is_gnu_ifunc ())
+           if (is_global && sym.symbol->type ()->is_gnu_ifunc ())
              addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
          }
          break;
 
        case LOC_CONST:
-         if (SYMBOL_TYPE (sym.symbol)->code () == TYPE_CODE_ENUM)
+         if (sym.symbol->type ()->code () == TYPE_CODE_ENUM)
            {
              /* Already handled by convert_enum.  */
              return;
@@ -190,7 +190,7 @@ convert_one_symbol (compile_cplus_instance *instance,
            {
              compile_scope scope
                = instance->new_scope (sym.symbol->natural_name (),
-                                      SYMBOL_TYPE (sym.symbol));
+                                      sym.symbol->type ());
              if (scope.nested_type () != GCC_TYPE_NONE)
                {
                  /* We found a symbol for this type that was defined inside
@@ -442,7 +442,7 @@ gcc_cplus_symbol_address (void *datum, struct gcc_cp_context *gcc_context,
                                "gcc_symbol_address \"%s\": full symbol\n",
                                identifier);
          result = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
-         if (SYMBOL_TYPE (sym)->is_gnu_ifunc ())
+         if (sym->type ()->is_gnu_ifunc ())
            result = gnu_ifunc_resolve_addr (target_gdbarch (), result);
          found = 1;
        }
index ce8b945268595e0b4e1f4ef54b52416e712b9522..1987996698653ff0e149ad5ed89e60bf90f578d9 100644 (file)
@@ -161,7 +161,7 @@ type_name_to_scope (const char *type_name, const struct block *block)
 
          scope.push_back (comp);
 
-         if (SYMBOL_TYPE (bsymbol.symbol)->code () != TYPE_CODE_NAMESPACE)
+         if (bsymbol.symbol->type ()->code () != TYPE_CODE_NAMESPACE)
            {
              /* We're done.  */
              break;
@@ -271,7 +271,7 @@ compile_cplus_instance::enter_scope (compile_scope &&new_scope)
        (m_scopes.back ().begin (), m_scopes.back ().end () - 1,
         [this] (const scope_component &comp)
         {
-         gdb_assert (SYMBOL_TYPE (comp.bsymbol.symbol)->code ()
+         gdb_assert (comp.bsymbol.symbol->type ()->code ()
                      == TYPE_CODE_NAMESPACE);
 
          const char *ns = (comp.name == CP_ANONYMOUS_NAMESPACE_STR ? nullptr
@@ -313,7 +313,7 @@ compile_cplus_instance::leave_scope ()
       std::for_each
        (current.begin (),current.end () - 1,
         [this] (const scope_component &comp) {
-         gdb_assert (SYMBOL_TYPE (comp.bsymbol.symbol)->code ()
+         gdb_assert (comp.bsymbol.symbol->type ()->code ()
                      == TYPE_CODE_NAMESPACE);
          this->plugin ().pop_binding_level (comp.name.c_str ());
        });
@@ -345,14 +345,14 @@ compile_cplus_instance::new_scope (const char *type_name, struct type *type)
         unqualified name of the type to process.  */
       scope_component &comp = scope.back ();
 
-      if (!types_equal (type, SYMBOL_TYPE (comp.bsymbol.symbol))
+      if (!types_equal (type, comp.bsymbol.symbol->type ())
          && (m_scopes.empty ()
              || (m_scopes.back ().back ().bsymbol.symbol
                  != comp.bsymbol.symbol)))
        {
          /* The type is defined inside another class(es).  Convert that
             type instead of defining this type.  */
-         convert_type (SYMBOL_TYPE (comp.bsymbol.symbol));
+         convert_type (comp.bsymbol.symbol->type ());
 
          /* If the original type (passed in to us) is defined in a nested
             class, the previous call will give us that type's gcc_type.
index 692e9906fd7d2a577cad12bc89f3292a823be5c5..073f2fe2fd32b69aacef926da87abf8ccb95dafc 100644 (file)
@@ -458,7 +458,7 @@ get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
   if (block_loop == nblocks)
     error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_VAL);
 
-  gdb_type = SYMBOL_TYPE (gdb_val_sym);
+  gdb_type = gdb_val_sym->type ();
   gdb_type = check_typedef (gdb_type);
 
   gdb_ptr_type_sym = block_lookup_symbol (block, COMPILE_I_EXPR_PTR_TYPE,
@@ -466,7 +466,7 @@ get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
                                          VAR_DOMAIN);
   if (gdb_ptr_type_sym == NULL)
     error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
-  gdb_ptr_type = SYMBOL_TYPE (gdb_ptr_type_sym);
+  gdb_ptr_type = gdb_ptr_type_sym->type ();
   gdb_ptr_type = check_typedef (gdb_ptr_type);
   if (gdb_ptr_type->code () != TYPE_CODE_PTR)
     error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE);
@@ -517,7 +517,7 @@ get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
 static struct type *
 get_regs_type (struct symbol *func_sym, struct objfile *objfile)
 {
-  struct type *func_type = SYMBOL_TYPE (func_sym);
+  struct type *func_type = func_sym->type ();
   struct type *regsp_type, *regs_type;
 
   /* No register parameter present.  */
@@ -656,7 +656,7 @@ compile_object_load (const compile_file_names &file_names,
   if (func_sym == NULL)
     error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
           GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
-  func_type = SYMBOL_TYPE (func_sym);
+  func_type = func_sym->type ();
   if (func_type->code () != TYPE_CODE_FUNC)
     error (_("Invalid type code %d of function \"%s\" in compiled "
             "module \"%s\"."),
index b2e09cab0715b3b8391ef81bf4337c068cdaf94f..bce0f82a1ee272a363582418f2af29ee11081143 100644 (file)
@@ -134,7 +134,7 @@ compile_object_run (compile_module_up &&module)
 
   try
     {
-      struct type *func_type = SYMBOL_TYPE (func_sym);
+      struct type *func_type = func_sym->type ();
       int current_arg = 0;
       struct value **vargs;
 
index 8fb2f71b46cc1dbd1887095ce174f645c9f65459..18238db2c87283b210b3dbba0339801e3d03084c 100644 (file)
@@ -220,7 +220,7 @@ cp_lookup_bare_symbol (const struct language_defn *langdef,
        return {};
 
 
-      type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
+      type = check_typedef (TYPE_TARGET_TYPE (lang_this.symbol->type ()));
       /* If TYPE_NAME is NULL, abandon trying to find this symbol.
         This can happen for lambda functions compiled with clang++,
         which outputs no name for the container class.  */
@@ -274,7 +274,7 @@ cp_search_static_and_baseclasses (const char *name,
   if (scope_sym.symbol == NULL)
     return {};
 
-  struct type *scope_type = SYMBOL_TYPE (scope_sym.symbol);
+  struct type *scope_type = scope_sym.symbol->type ();
 
   /* If the scope is a function/method, then look up NESTED as a local
      static variable.  E.g., "print 'function()::static_var'".  */
index f146183f37751281961b0d828b9287d91ecd5754..0be1a04852f9aa9b095526fdd75549102ea0477e 100644 (file)
@@ -166,7 +166,7 @@ inspect_type (struct demangle_parse_info *info,
 
   if (sym != NULL)
     {
-      struct type *otype = SYMBOL_TYPE (sym);
+      struct type *otype = sym->type ();
 
       if (finder != NULL)
        {
@@ -512,7 +512,7 @@ replace_typedefs (struct demangle_parse_info *info,
 
              if (sym != NULL)
                {
-                 struct type *otype = SYMBOL_TYPE (sym);
+                 struct type *otype = sym->type ();
                  const char *new_name = (*finder) (otype, data);
 
                  if (new_name != NULL)
@@ -1215,7 +1215,7 @@ overload_list_add_symbol (struct symbol *sym,
 {
   /* If there is no type information, we can't do anything, so
      skip.  */
-  if (SYMBOL_TYPE (sym) == NULL)
+  if (sym->type () == NULL)
     return;
 
   /* skip any symbols that we've already considered.  */
@@ -1507,7 +1507,7 @@ cp_lookup_rtti_type (const char *name, const struct block *block)
       return NULL;
     }
 
-  rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym));
+  rtti_type = check_typedef (rtti_sym->type ());
 
   switch (rtti_type->code ())
     {
index 2f8c039165946060e25b9762fa6ae9aa7abb1be9..5d965bb0e08cc98e3057e284c0001a8e919de297 100644 (file)
@@ -452,7 +452,7 @@ ctf_add_enum_member_cb (const char *name, int enum_value, void *arg)
       sym->compute_and_set_names (name, false, ccp->of->per_bfd);
       sym->set_aclass_index (LOC_CONST);
       sym->set_domain (VAR_DOMAIN);
-      SYMBOL_TYPE (sym) = fip->ptype;
+      sym->set_type (fip->ptype);
       add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
     }
 
@@ -483,7 +483,7 @@ new_symbol (struct ctf_context *ccp, struct type *type, ctf_id_t tid)
       sym->set_aclass_index (LOC_OPTIMIZED_OUT);
 
       if (type != nullptr)
-       SYMBOL_TYPE (sym) = type;
+       sym->set_type (type);
 
       uint32_t kind = ctf_type_kind (fp, tid);
       switch (kind)
@@ -499,8 +499,8 @@ new_symbol (struct ctf_context *ccp, struct type *type, ctf_id_t tid)
            set_symbol_address (objfile, sym, sym->linkage_name ());
            break;
          case CTF_K_CONST:
-           if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_VOID)
-             SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
+           if (sym->type ()->code () == TYPE_CODE_VOID)
+             sym->set_type (objfile_type (objfile)->builtin_int);
            break;
          case CTF_K_TYPEDEF:
          case CTF_K_INTEGER:
@@ -1169,7 +1169,7 @@ ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
          }
        sym = new (&ccp->of->objfile_obstack) symbol;
        OBJSTAT (ccp->of, n_syms++);
-       SYMBOL_TYPE (sym) = type;
+       sym->set_type (type);
        sym->set_domain (VAR_DOMAIN);
        sym->set_aclass_index (LOC_OPTIMIZED_OUT);
        sym->compute_and_set_names (name, false, ccp->of->per_bfd);
@@ -1205,7 +1205,7 @@ add_stt_entries (struct ctf_context *ccp, int functions)
        continue;
       sym = new (&ccp->of->objfile_obstack) symbol;
       OBJSTAT (ccp->of, n_syms++);
-      SYMBOL_TYPE (sym) = type;
+      sym->set_type (type);
       sym->set_domain (VAR_DOMAIN);
       sym->set_aclass_index (LOC_STATIC);
       sym->compute_and_set_names (tname, false, ccp->of->per_bfd);
index 601659d080d38c7802ddbcb76e4b334b9a702737..027a8fa206dab145a84d99cf116bbbdb7b792341 100644 (file)
@@ -1343,7 +1343,7 @@ classify_name (struct parser_state *par_state, const struct block *block)
   sym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN, &is_a_field_of_this);
   if (sym.symbol && sym.symbol->aclass () == LOC_TYPEDEF)
     {
-      yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
+      yylval.tsym.type = sym.symbol->type ();
       return TYPENAME;
     }
   else if (sym.symbol == NULL)
@@ -1355,7 +1355,7 @@ classify_name (struct parser_state *par_state, const struct block *block)
 
       if (sym.symbol != NULL)
        {
-         yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
+         yylval.tsym.type = sym.symbol->type ();
          return TYPENAME;
        }
 
@@ -1390,7 +1390,7 @@ classify_inner_name (struct parser_state *par_state,
 
   if (yylval.ssym.sym.symbol->aclass () == LOC_TYPEDEF)
     {
-      yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
+      yylval.tsym.type = yylval.ssym.sym.symbol->type ();
       return TYPENAME;
     }
 
index eab99cec672058b39a13bd7c233008bcdd170ee8..07c22e0eae54da4d081ff8a1e9acaeebba35c0a8 100644 (file)
@@ -130,7 +130,7 @@ d_lookup_symbol (const struct language_defn *langdef,
          if (lang_this.symbol == NULL)
            return {};
 
-         type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
+         type = check_typedef (TYPE_TARGET_TYPE (lang_this.symbol->type ()));
          classname = type->name ();
          nested = name;
        }
@@ -151,7 +151,7 @@ d_lookup_symbol (const struct language_defn *langdef,
        return {};
 
       /* Look for a symbol named NESTED in this class.  */
-      sym = d_lookup_nested_symbol (SYMBOL_TYPE (class_sym.symbol),
+      sym = d_lookup_nested_symbol (class_sym.symbol->type (),
                                    nested.c_str (), block);
     }
 
index bf3cadba87eefc6c47258d193b8b5206d9d9d4b9..badc7f89078949fe97091ed538c4dc0a2dc2d500 100644 (file)
@@ -744,7 +744,7 @@ func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr)
                   "name for address %s"),
                 paddress (gdbarch, addr));
 
-  type = SYMBOL_TYPE (sym);
+  type = sym->type ();
   gdb_assert (type->code () == TYPE_CODE_FUNC);
   gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
 
@@ -783,7 +783,7 @@ func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
 
       func_sym = func_addr_to_tail_call_list (gdbarch, addr);
 
-      for (call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym));
+      for (call_site = TYPE_TAIL_CALL_LIST (func_sym->type ());
           call_site; call_site = call_site->tail_call_next)
        {
          CORE_ADDR target_addr;
@@ -985,7 +985,7 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
          struct symbol *target_func;
 
          target_func = func_addr_to_tail_call_list (gdbarch, target_func_addr);
-         target_call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func));
+         target_call_site = TYPE_TAIL_CALL_LIST (target_func->type ());
        }
 
       do
@@ -3019,7 +3019,7 @@ locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
     = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
   struct value *val;
 
-  val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
+  val = dwarf2_evaluate_loc_desc (symbol->type (), frame, dlbaton->data,
                                  dlbaton->size, dlbaton->per_cu,
                                  dlbaton->per_objfile);
 
@@ -3036,7 +3036,7 @@ locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
   struct dwarf2_locexpr_baton *dlbaton
     = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
 
-  return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
+  return value_of_dwarf_block_entry (symbol->type (), frame, dlbaton->data,
                                     dlbaton->size);
 }
 
@@ -3856,7 +3856,7 @@ loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
   CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
 
   data = dwarf2_find_location_expression (dlbaton, &size, pc);
-  val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
+  val = dwarf2_evaluate_loc_desc (symbol->type (), frame, data, size,
                                  dlbaton->per_cu, dlbaton->per_objfile);
 
   return val;
@@ -3880,13 +3880,13 @@ loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
   CORE_ADDR pc;
 
   if (frame == NULL || !get_frame_func_if_available (frame, &pc))
-    return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
+    return allocate_optimized_out_value (symbol->type ());
 
   data = dwarf2_find_location_expression (dlbaton, &size, pc);
   if (data == NULL)
-    return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
+    return allocate_optimized_out_value (symbol->type ());
 
-  return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, data, size);
+  return value_of_dwarf_block_entry (symbol->type (), frame, data, size);
 }
 
 /* Implementation of get_symbol_read_needs from
index 95d4d6fc5532e6889253b4334224c5ffa407dd1a..3a22bcdd43d85c106b62ffa0ae668b73e8a64d72 100644 (file)
@@ -8918,7 +8918,7 @@ fixup_go_packaging (struct dwarf2_cu *cu)
         e.g., "main" finds the "main" module and not C's main().  */
       sym->set_domain (STRUCT_DOMAIN);
       sym->set_aclass_index (LOC_TYPEDEF);
-      SYMBOL_TYPE (sym) = type;
+      sym->set_type (type);
 
       add_symbol_to_list (sym, cu->get_builder ()->get_global_symbols ());
     }
@@ -21720,9 +21720,9 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
       sym->set_domain (VAR_DOMAIN);
       sym->set_aclass_index (LOC_OPTIMIZED_OUT);
       if (type != NULL)
-       SYMBOL_TYPE (sym) = type;
+       sym->set_type (type);
       else
-       SYMBOL_TYPE (sym) = die_type (die, cu);
+       sym->set_type (die_type (die, cu));
       attr = dwarf2_attr (die,
                          inlined_func ? DW_AT_call_line : DW_AT_decl_line,
                          cu);
@@ -21764,7 +21764,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
            }
          else
            sym->set_aclass_index (LOC_OPTIMIZED_OUT);
-         SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
+         sym->set_type (objfile_type (objfile)->builtin_core_addr);
          sym->set_domain (LABEL_DOMAIN);
          add_symbol_to_list (sym, cu->list_in_scope);
          break;
@@ -21806,8 +21806,8 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
          /* Compilation with minimal debug info may result in
             variables with missing type entries.  Change the
             misleading `void' type to something sensible.  */
-         if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_VOID)
-           SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
+         if (sym->type ()->code () == TYPE_CODE_VOID)
+           sym->set_type (objfile_type (objfile)->builtin_int);
 
          attr = dwarf2_attr (die, DW_AT_const_value, cu);
          /* In the case of DW_TAG_member, we should only be called for
@@ -21994,8 +21994,8 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
                    /* The symbol's name is already allocated along
                       with this objfile, so we don't need to
                       duplicate it for the type.  */
-                   if (SYMBOL_TYPE (sym)->name () == 0)
-                     SYMBOL_TYPE (sym)->set_name (sym->search_name ());
+                   if (sym->type ()->name () == 0)
+                     sym->type ()->set_name (sym->search_name ());
                  }
              }
          }
@@ -22230,7 +22230,7 @@ dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
   const gdb_byte *bytes;
   struct dwarf2_locexpr_baton *baton;
 
-  dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
+  dwarf2_const_value_attr (attr, sym->type (),
                           sym->print_name (),
                           &objfile->objfile_obstack, cu,
                           &value, &bytes, &baton);
index 91ff41cfe25aa97b0305cb2410fd7b32f68b427a..6ced0b261e78c7d37bdfd28345a1517f8dcb0385 100644 (file)
@@ -564,7 +564,7 @@ evaluate_var_value (enum noside noside, const block *blk, symbol *var)
       if (noside != EVAL_AVOID_SIDE_EFFECTS)
        throw;
 
-      ret = value_zero (SYMBOL_TYPE (var), not_lval);
+      ret = value_zero (var->type (), not_lval);
     }
 
   return ret;
@@ -580,7 +580,7 @@ var_value_operation::evaluate (struct type *expect_type,
                               enum noside noside)
 {
   symbol *var = std::get<0> (m_storage).symbol;
-  if (SYMBOL_TYPE (var)->code () == TYPE_CODE_ERROR)
+  if (var->type ()->code () == TYPE_CODE_ERROR)
     error_unknown_type (var->print_name ());
   return evaluate_var_value (noside, std::get<0> (m_storage).block, var);
 }
@@ -722,7 +722,7 @@ var_value_operation::evaluate_funcall (struct type *expect_type,
                       NULL, std::get<0> (m_storage).symbol,
                       NULL, &symp, NULL, 0, noside);
 
-  if (SYMBOL_TYPE (symp)->code () == TYPE_CODE_ERROR)
+  if (symp->type ()->code () == TYPE_CODE_ERROR)
     error_unknown_type (symp->print_name ());
   value *callee = evaluate_var_value (noside, std::get<0> (m_storage).block,
                                      symp);
@@ -1005,7 +1005,7 @@ eval_op_var_entry_value (struct type *expect_type, struct expression *exp,
                         enum noside noside, symbol *sym)
 {
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    return value_zero (SYMBOL_TYPE (sym), not_lval);
+    return value_zero (sym->type (), not_lval);
 
   if (SYMBOL_COMPUTED_OPS (sym) == NULL
       || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
@@ -2261,7 +2261,7 @@ adl_func_operation::evaluate (struct type *expect_type,
                       NON_METHOD,
                       nullptr, nullptr,
                       nullptr, &symp, nullptr, 0, noside);
-  if (SYMBOL_TYPE (symp)->code () == TYPE_CODE_ERROR)
+  if (symp->type ()->code () == TYPE_CODE_ERROR)
     error_unknown_type (symp->print_name ());
   value *callee = evaluate_var_value (noside, std::get<1> (m_storage), symp);
   return evaluate_subexp_do_call (exp, noside, callee, args,
@@ -2582,12 +2582,12 @@ var_value_operation::evaluate_for_address (struct expression *exp,
 
   /* C++: The "address" of a reference should yield the address
    * of the object pointed to.  Let value_addr() deal with it.  */
-  if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var)))
+  if (TYPE_IS_REFERENCE (var->type ()))
     return operation::evaluate_for_address (exp, noside);
 
   if (noside == EVAL_AVOID_SIDE_EFFECTS)
     {
-      struct type *type = lookup_pointer_type (SYMBOL_TYPE (var));
+      struct type *type = lookup_pointer_type (var->type ());
       enum address_class sym_class = var->aclass ();
 
       if (sym_class == LOC_CONST
@@ -2606,7 +2606,7 @@ var_value_operation::evaluate_with_coercion (struct expression *exp,
                                             enum noside noside)
 {
   struct symbol *var = std::get<0> (m_storage).symbol;
-  struct type *type = check_typedef (SYMBOL_TYPE (var));
+  struct type *type = check_typedef (var->type ());
   if (type->code () == TYPE_CODE_ARRAY
       && !type->is_vector ()
       && CAST_IS_CONVERSION (exp->language_defn))
@@ -2735,7 +2735,7 @@ value *
 var_value_operation::evaluate_for_sizeof (struct expression *exp,
                                          enum noside noside)
 {
-  struct type *type = SYMBOL_TYPE (std::get<0> (m_storage).symbol);
+  struct type *type = std::get<0> (m_storage).symbol->type ();
   if (is_dynamic_type (type))
     {
       value *val = evaluate (nullptr, exp, EVAL_NORMAL);
index 13f8c10897fcaa7d824e02c0a1527eac051c68f6..9cba30f68379f925520027d122089cd947c17a2e 100644 (file)
@@ -1489,7 +1489,7 @@ yylex (void)
                                domain, NULL);
        if (result.symbol && result.symbol->aclass () == LOC_TYPEDEF)
          {
-           yylval.tsym.type = SYMBOL_TYPE (result.symbol);
+           yylval.tsym.type = result.symbol->type ();
            return TYPENAME;
          }
 
index f5c880d65963363eff01e99fd618397fd2fc722b..47c98ab9793039397ad21fb4c2593a0e5f3a12da 100644 (file)
@@ -1952,9 +1952,9 @@ fbsd_fetch_rtld_offsets (struct gdbarch *gdbarch, struct fbsd_pspace_data *data)
                                     language_c, NULL).symbol;
       if (obj_entry_sym == NULL)
        error (_("Unable to find Struct_Obj_Entry symbol"));
-      data->off_linkmap = lookup_struct_elt (SYMBOL_TYPE (obj_entry_sym),
+      data->off_linkmap = lookup_struct_elt (obj_entry_sym->type (),
                                             "linkmap", 0).offset / 8;
-      data->off_tlsindex = lookup_struct_elt (SYMBOL_TYPE (obj_entry_sym),
+      data->off_tlsindex = lookup_struct_elt (obj_entry_sym->type (),
                                              "tlsindex", 0).offset / 8;
       data->rtld_offsets_valid = true;
       return;
index fdfad599f32e410ec838005f73dd558103db307f..1d22e645305e0bd6ddb0d55f226039e7db4cf5e1 100644 (file)
@@ -593,7 +593,7 @@ language_defn::read_var_value (struct symbol *var,
                               struct frame_info *frame) const
 {
   struct value *v;
-  struct type *type = SYMBOL_TYPE (var);
+  struct type *type = var->type ();
   CORE_ADDR addr;
   enum symbol_needs_kind sym_need;
 
index 2e7f6540f94f88cd15338077b4216beb107e7266..ff07086b46f8ce10c0126277ef1fa46d84e040b3 100644 (file)
@@ -1691,7 +1691,7 @@ lookup_typename (const struct language_defn *language,
   sym = lookup_symbol_in_language (name, block, VAR_DOMAIN,
                                   language->la_language, NULL).symbol;
   if (sym != NULL && sym->aclass () == LOC_TYPEDEF)
-    return SYMBOL_TYPE (sym);
+    return sym->type ();
 
   if (noerr)
     return NULL;
@@ -1738,12 +1738,12 @@ lookup_struct (const char *name, const struct block *block)
     {
       error (_("No struct type named %s."), name);
     }
-  if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_STRUCT)
+  if (sym->type ()->code () != TYPE_CODE_STRUCT)
     {
       error (_("This context has class, union or enum %s, not a struct."),
             name);
     }
-  return (SYMBOL_TYPE (sym));
+  return (sym->type ());
 }
 
 /* Lookup a union type named "union NAME",
@@ -1760,7 +1760,7 @@ lookup_union (const char *name, const struct block *block)
   if (sym == NULL)
     error (_("No union type named %s."), name);
 
-  t = SYMBOL_TYPE (sym);
+  t = sym->type ();
 
   if (t->code () == TYPE_CODE_UNION)
     return t;
@@ -1783,12 +1783,12 @@ lookup_enum (const char *name, const struct block *block)
     {
       error (_("No enum type named %s."), name);
     }
-  if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_ENUM)
+  if (sym->type ()->code () != TYPE_CODE_ENUM)
     {
       error (_("This context has class, struct or union %s, not an enum."), 
             name);
     }
-  return (SYMBOL_TYPE (sym));
+  return (sym->type ());
 }
 
 /* Lookup a template type named "template NAME<TYPE>",
@@ -1813,12 +1813,12 @@ lookup_template_type (const char *name, struct type *type,
     {
       error (_("No template type named %s."), name);
     }
-  if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_STRUCT)
+  if (sym->type ()->code () != TYPE_CODE_STRUCT)
     {
       error (_("This context has class, union or enum %s, not a struct."),
             name);
     }
-  return (SYMBOL_TYPE (sym));
+  return (sym->type ());
 }
 
 /* See gdbtypes.h.  */
@@ -2906,7 +2906,7 @@ check_typedef (struct type *type)
            }
          sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0).symbol;
          if (sym)
-           TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
+           TYPE_TARGET_TYPE (type) = sym->type ();
          else                                  /* TYPE_CODE_UNDEF */
            TYPE_TARGET_TYPE (type) = alloc_type_arch (type->arch ());
        }
@@ -3000,11 +3000,11 @@ check_typedef (struct type *type)
          /* Same as above for opaque types, we can replace the stub
             with the complete type only if they are in the same
             objfile.  */
-         if (SYMBOL_TYPE (sym)->objfile_owner () == type->objfile_owner ())
-           type = make_qualified_type (SYMBOL_TYPE (sym),
+         if (sym->type ()->objfile_owner () == type->objfile_owner ())
+           type = make_qualified_type (sym->type (),
                                        type->instance_flags (), type);
          else
-           type = SYMBOL_TYPE (sym);
+           type = sym->type ();
        }
     }
 
index 270a8b4b46f970141c76db1c90f10d8509984f96..0cbb8d0d3a63f1efa03cf9359684a8070b9d5475 100644 (file)
@@ -1071,7 +1071,7 @@ gnuv3_get_typeid_type (struct gdbarch *gdbarch)
     typeinfo_type
       = (struct type *) gdbarch_data (gdbarch, std_type_info_gdbarch_data);
   else
-    typeinfo_type = SYMBOL_TYPE (typeinfo);
+    typeinfo_type = typeinfo->type ();
 
   return typeinfo_type;
 }
index fed7fe531f982e1b7afa21ce9fc207da15f68034..456920456cde957e45e1b40586de51e590208902 100644 (file)
@@ -1339,7 +1339,7 @@ package_name_p (const char *name, const struct block *block)
 
   if (sym
       && sym->aclass () == LOC_TYPEDEF
-      && SYMBOL_TYPE (sym)->code () == TYPE_CODE_MODULE)
+      && sym->type ()->code () == TYPE_CODE_MODULE)
     return 1;
 
   return 0;
index 32ef3361941ab6070ddc88feaaef9d52cd8a5ba8..4c28603fa63674660ed58c69dd984d5e6d2ef82f 100644 (file)
@@ -345,10 +345,10 @@ gdbscm_symbol_type (SCM self)
     = syscm_get_valid_symbol_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
   const struct symbol *symbol = s_smob->symbol;
 
-  if (SYMBOL_TYPE (symbol) == NULL)
+  if (symbol->type () == NULL)
     return SCM_BOOL_F;
 
-  return tyscm_scm_from_type (SYMBOL_TYPE (symbol));
+  return tyscm_scm_from_type (symbol->type ());
 }
 
 /* (symbol-symtab <gdb:symbol>) -> <gdb:symtab> | #f
index b02040f68d3bb9aab96e52daa51205981e5cb037..b9fb121dbbe62015f88e78878ec5ac02bb28357a 100644 (file)
@@ -1567,7 +1567,7 @@ finish_command_fsm::should_stop (struct thread_info *tp)
       /* We're done.  */
       set_finished ();
 
-      rv->type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
+      rv->type = TYPE_TARGET_TYPE (function->type ());
       if (rv->type == NULL)
        internal_error (__FILE__, __LINE__,
                        _("finish_command: function has no target type"));
@@ -1803,7 +1803,7 @@ finish_command (const char *arg, int from_tty)
        printf_filtered (_("Run back to call of "));
       else
        {
-         if (sm->function != NULL && TYPE_NO_RETURN (sm->function->type)
+         if (sm->function != NULL && TYPE_NO_RETURN (sm->function->type ())
              && !query (_("warning: Function %s does not return normally.\n"
                           "Try to finish anyway? "),
                         sm->function->print_name ()))
index d13b9b2043457ef0dc3fe1a0e9e258c072479fb4..7819d763ab3b061a673cb90682c2ab43cc2e75e3 100644 (file)
--- a/gdb/jit.c
+++ b/gdb/jit.c
@@ -562,7 +562,7 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
       block_name->set_domain (VAR_DOMAIN);
       block_name->set_aclass_index (LOC_BLOCK);
       symbol_set_symtab (block_name, filetab);
-      SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
+      block_name->set_type (lookup_function_type (block_type));
       SYMBOL_BLOCK_VALUE (block_name) = new_block;
 
       block_name->m_name = obstack_strdup (&objfile->objfile_obstack,
index 1d4b1b31252566e08877b3abede63e1830ed457d..69c73b0318e1b46db6ffc0eb8bc125aac0cf65bf 100644 (file)
@@ -975,7 +975,7 @@ language_arch_info::bool_type () const
       sym = lookup_symbol (m_bool_type_name, NULL, VAR_DOMAIN, NULL).symbol;
       if (sym != nullptr)
        {
-         struct type *type = SYMBOL_TYPE (sym);
+         struct type *type = sym->type ();
          if (type != nullptr && type->code () == TYPE_CODE_BOOL)
            return type;
        }
@@ -1000,7 +1000,7 @@ language_arch_info::type_and_symbol::alloc_type_symbol
   symbol->owner.arch = gdbarch;
   symbol->set_is_objfile_owned (0);
   symbol->set_section_index (0);
-  SYMBOL_TYPE (symbol) = type;
+  symbol->set_type (type);
   symbol->set_domain (VAR_DOMAIN);
   symbol->set_aclass_index (LOC_TYPEDEF);
   return symbol;
index 7c403679455b8ad5f25966bacf132e85cb48cc92..a8ae5943811a7c311b23b4ef60485efe216949cd 100644 (file)
@@ -3494,7 +3494,7 @@ decode_compound_collector::operator () (block_symbol *bsym)
   if (sym->aclass () != LOC_TYPEDEF)
     return true; /* Continue iterating.  */
 
-  t = SYMBOL_TYPE (sym);
+  t = sym->type ();
   t = check_typedef (t);
   if (t->code () != TYPE_CODE_STRUCT
       && t->code () != TYPE_CODE_UNION
@@ -3686,7 +3686,7 @@ find_method (struct linespec_state *self,
       pspace = symbol_symtab (sym)->pspace ();
       gdb_assert (!pspace->executing_startup);
       set_current_program_space (pspace);
-      t = check_typedef (SYMBOL_TYPE (sym));
+      t = check_typedef (sym->type ());
       find_methods (t, sym->language (),
                    method_name, &result_names, &superclass_vec);
 
index f3685f75b72321d77745fdfb66a5a473414caf39..7607fd753c5a616cdd8e2889c24072eb0d0ca5a6 100644 (file)
@@ -163,8 +163,8 @@ m2_language::print_typedef (struct type *type, struct symbol *new_symbol,
 {
   type = check_typedef (type);
   fprintf_filtered (stream, "TYPE ");
-  if (!SYMBOL_TYPE (new_symbol)->name ()
-      || strcmp ((SYMBOL_TYPE (new_symbol))->name (),
+  if (!new_symbol->type ()->name ()
+      || strcmp ((new_symbol->type ())->name (),
                 new_symbol->linkage_name ()) != 0)
     fprintf_filtered (stream, "%s = ", new_symbol->print_name ());
   else
index a295878b625aeaae3856669ecf98b09f13e20847..8ede3d6aa269bb4bd45933137b8432d420a0d6c9 100644 (file)
@@ -569,9 +569,9 @@ add_data_symbol (SYMR *sh, union aux_ext *ax, int bigend,
   /* Type could be missing if file is compiled without debugging info.  */
   if (SC_IS_UNDEF (sh->sc)
       || sh->sc == scNil || sh->index == indexNil)
-    SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol;
+    s->set_type (objfile_type (objfile)->nodebug_data_symbol);
   else
-    SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
+    s->set_type (parse_type (cur_fd, ax, sh->index, 0, bigend, name));
   /* Value of a data symbol is its memory address.  */
 }
 
@@ -697,7 +697,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
          break;
        }
       SYMBOL_VALUE (s) = svalue;
-      SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
+      s->set_type (parse_type (cur_fd, ax, sh->index, 0, bigend, name));
       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
       break;
 
@@ -706,7 +706,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       s->set_domain (VAR_DOMAIN);      /* So that it can be used */
       s->set_aclass_index (LOC_LABEL); /* but not misused.  */
       SET_SYMBOL_VALUE_ADDRESS (s, (CORE_ADDR) sh->value);
-      SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;
+      s->set_type (objfile_type (objfile)->builtin_int);
       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
       break;
 
@@ -787,12 +787,12 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       add_symbol (s, top_stack->cur_st, b);
 
       /* Make a type for the procedure itself.  */
-      SYMBOL_TYPE (s) = lookup_function_type (t);
+      s->set_type (lookup_function_type (t));
 
       /* All functions in C++ have prototypes.  For C we don't have enough
         information in the debug info.  */
       if (s->language () == language_cplus)
-       SYMBOL_TYPE (s)->set_is_prototyped (true);
+       s->type ()->set_is_prototyped (true);
 
       /* Create and enter a new lexical context.  */
       b = new_block (FUNCTION_BLOCK, s->language ());
@@ -809,7 +809,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       push_parse_stack ();
       top_stack->cur_block = b;
       top_stack->blocktype = sh->st;
-      top_stack->cur_type = SYMBOL_TYPE (s);
+      top_stack->cur_type = s->type ();
       top_stack->cur_field = -1;
       top_stack->procadr = sh->value;
       top_stack->numargs = 0;
@@ -1066,7 +1066,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
                  (obstack_strdup (&mdebugread_objfile->objfile_obstack,
                                   f->name ()));
                enum_sym->set_aclass_index (LOC_CONST);
-               SYMBOL_TYPE (enum_sym) = t;
+               enum_sym->set_type (t);
                enum_sym->set_domain (VAR_DOMAIN);
                SYMBOL_VALUE (enum_sym) = tsym.value;
                if (SYMBOL_VALUE (enum_sym) < 0)
@@ -1100,7 +1100,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
        s->set_domain (STRUCT_DOMAIN);
        s->set_aclass_index (LOC_TYPEDEF);
        SYMBOL_VALUE (s) = 0;
-       SYMBOL_TYPE (s) = t;
+       s->set_type (t);
        add_symbol (s, top_stack->cur_st, top_stack->cur_block);
        break;
 
@@ -1156,7 +1156,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
          s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
          s->set_domain (LABEL_DOMAIN);
          s->set_aclass_index (LOC_CONST);
-         SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->builtin_void;
+         s->set_type (objfile_type (mdebugread_objfile)->builtin_void);
          e = OBSTACK_ZALLOC (&mdebugread_objfile->objfile_obstack,
                              mdebug_extra_func_info);
          SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
@@ -1204,7 +1204,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 
                      if (sym->is_argument ())
                        {
-                         ftype->field (iparams).set_type (SYMBOL_TYPE (sym));
+                         ftype->field (iparams).set_type (sym->type ());
                          TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
                          iparams++;
                        }
@@ -1298,17 +1298,17 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       s->set_domain (VAR_DOMAIN);
       s->set_aclass_index (LOC_TYPEDEF);
       SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
-      SYMBOL_TYPE (s) = t;
+      s->set_type (t);
       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
 
       /* Incomplete definitions of structs should not get a name.  */
-      if (SYMBOL_TYPE (s)->name () == NULL
-         && (SYMBOL_TYPE (s)->num_fields () != 0
-             || (SYMBOL_TYPE (s)->code () != TYPE_CODE_STRUCT
-                 && SYMBOL_TYPE (s)->code () != TYPE_CODE_UNION)))
+      if (s->type ()->name () == NULL
+         && (s->type ()->num_fields () != 0
+             || (s->type ()->code () != TYPE_CODE_STRUCT
+                 && s->type ()->code () != TYPE_CODE_UNION)))
        {
-         if (SYMBOL_TYPE (s)->code () == TYPE_CODE_PTR
-             || SYMBOL_TYPE (s)->code () == TYPE_CODE_FUNC)
+         if (s->type ()->code () == TYPE_CODE_PTR
+             || s->type ()->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
@@ -1330,7 +1330,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
                 for anything except pointers or functions.  */
            }
          else
-           SYMBOL_TYPE (s)->set_name (s->linkage_name ());
+           s->type ()->set_name (s->linkage_name ());
        }
       break;
 
@@ -1990,7 +1990,7 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab,
       s->set_domain (VAR_DOMAIN);
       SYMBOL_CLASS (s) = LOC_BLOCK;
       /* Don't know its type, hope int is ok.  */
-      SYMBOL_TYPE (s)
+      s->type ()
        = lookup_function_type (objfile_type (pst->objfile)->builtin_int);
       add_symbol (s, top_stack->cur_st, top_stack->cur_block);
       /* Won't have symbols for this one.  */
@@ -2044,8 +2044,8 @@ parse_procedure (PDR *pr, struct compunit_symtab *search_symtab,
 
   if (processing_gcc_compilation == 0
       && found_ecoff_debugging_info == 0
-      && TYPE_TARGET_TYPE (SYMBOL_TYPE (s))->code () == TYPE_CODE_VOID)
-    SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->nodebug_text_symbol;
+      && TYPE_TARGET_TYPE (s->type ())->code () == TYPE_CODE_VOID)
+    s->set_type (objfile_type (mdebugread_objfile)->nodebug_text_symbol);
 }
 
 /* Parse the external symbol ES.  Just call parse_symbol() after
@@ -3989,7 +3989,7 @@ mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile)
 
                  s->set_domain (LABEL_DOMAIN);
                  s->set_aclass_index (LOC_CONST);
-                 SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_void;
+                 s->set_type (objfile_type (objfile)->builtin_void);
                  SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
                  e->pdr.framereg = -1;
                  add_symbol_to_list (s, get_local_symbols ());
index ed22f3435e0f80bffa879084c67c0ec781c5f5f8..e63f1706149754603d3eb6fbead0abbe07686235 100644 (file)
@@ -525,8 +525,8 @@ list_arg_or_local (const struct frame_arg *arg, enum what_to_list what,
 
   if (values == PRINT_SIMPLE_VALUES)
     {
-      check_typedef (arg->sym->type);
-      type_print (arg->sym->type, "", &stb, -1);
+      check_typedef (arg->sym->type ());
+      type_print (arg->sym->type (), "", &stb, -1);
       uiout->field_stream ("type", stb);
     }
 
@@ -648,7 +648,7 @@ list_args_or_locals (const frame_print_options &fp_opts,
              switch (values)
                {
                case PRINT_SIMPLE_VALUES:
-                 type = check_typedef (sym2->type);
+                 type = check_typedef (sym2->type ());
                  if (type->code () != TYPE_CODE_ARRAY
                      && type->code () != TYPE_CODE_STRUCT
                      && type->code () != TYPE_CODE_UNION)
index a8edce386d23397be162044af486b8bf5f701481..6ed26d69269d63cb3834c8ab0701be9a796c5342 100644 (file)
@@ -81,7 +81,7 @@ output_debug_symbol (ui_out *uiout, enum search_domain kind,
   if (kind == FUNCTIONS_DOMAIN || kind == VARIABLES_DOMAIN)
     {
       string_file tmp_stream;
-      type_print (SYMBOL_TYPE (sym), "", &tmp_stream, -1);
+      type_print (sym->type (), "", &tmp_stream, -1);
       uiout->field_string ("type", tmp_stream.string ());
 
       std::string str = symbol_to_info_string (sym, block, kind);
index 72470144abf2602d343c344093f50ecce99726a2..3bb9588ad480819b514846c42f030d2ff4f32f8a 100644 (file)
@@ -96,7 +96,7 @@ lookup_struct_typedef (const char *name, const struct block *block, int noerr)
       else 
        error (_("No struct type named %s."), name);
     }
-  if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_STRUCT)
+  if (sym->type ()->code () != TYPE_CODE_STRUCT)
     {
       if (noerr)
        return 0;
@@ -210,7 +210,7 @@ value_nsstring (struct gdbarch *gdbarch, const char *ptr, int len)
   if (sym == NULL)
     type = builtin_type (gdbarch)->builtin_data_ptr;
   else
-    type = lookup_pointer_type(SYMBOL_TYPE (sym));
+    type = lookup_pointer_type(sym->type ());
 
   deprecated_set_value_type (nsstringValue, type);
   return nsstringValue;
index c7fa0dc882dcfef9c0e3764edf449d2cbd7421eb..024a335453a1d627c665925f982e9fc5eacc23e5 100644 (file)
@@ -690,7 +690,7 @@ variable:   name_not_typename
                                pstate->block_tracker->update (sym);
 
                              pstate->push_new<var_value_operation> (sym);
-                             current_type = sym.symbol->type; }
+                             current_type = sym.symbol->type (); }
                          else if ($1.is_a_field_of_this)
                            {
                              struct value * this_val;
@@ -1640,9 +1640,9 @@ yylex (void)
                break;
            }
 
-         yylval.tsym.type = SYMBOL_TYPE (best_sym);
+         yylval.tsym.type = best_sym->type ();
 #else /* not 0 */
-         yylval.tsym.type = SYMBOL_TYPE (sym);
+         yylval.tsym.type = sym->type ();
 #endif /* not 0 */
          free (uptokstart);
          return TYPENAME;
index a88d6b9a82cd496d60ebee62a4fd9ab5c1d01d32..8334ab9fe8443f1a2c7f18e69417ec5e8f0949e4 100644 (file)
@@ -255,7 +255,7 @@ pascal_language::value_print_inner (struct value *val,
 
              if (wsym)
                {
-                 wtype = SYMBOL_TYPE (wsym);
+                 wtype = wsym->type ();
                }
              else
                {
index 03bd49345060fa48dec07298af3e4b4d50d775fa..77e19f6deee24ebd5b5d8ea6ccec473b1969032f 100644 (file)
@@ -250,7 +250,7 @@ bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
          if (function != NULL)
            {
              struct type *ret_type =
-               check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (function)));
+               check_typedef (TYPE_TARGET_TYPE (function->type ()));
 
              /* Remember only non-void return types.  */
              if (ret_type->code () != TYPE_CODE_VOID)
index c756870adb6cef98cae282f9762d1d9874683de8..747da481a1bf7bc17394fceb22ef06456a9788dd 100644 (file)
@@ -72,13 +72,13 @@ sympy_get_type (PyObject *self, void *closure)
 
   SYMPY_REQUIRE_VALID (self, symbol);
 
-  if (SYMBOL_TYPE (symbol) == NULL)
+  if (symbol->type () == NULL)
     {
       Py_INCREF (Py_None);
       return Py_None;
     }
 
-  return type_to_type_object (SYMBOL_TYPE (symbol));
+  return type_to_type_object (symbol->type ());
 }
 
 static PyObject *
index 6ab551a852009d958b9e639a93fe50cc930d73cb..9df667d2811df9c4df927e4fb4c4aedcc782461e 100644 (file)
@@ -998,7 +998,7 @@ typy_template_argument (PyObject *self, PyObject *args)
 
   sym = TYPE_TEMPLATE_ARGUMENT (type, argno);
   if (sym->aclass () == LOC_TYPEDEF)
-    return type_to_type_object (SYMBOL_TYPE (sym));
+    return type_to_type_object (sym->type ());
   else if (sym->aclass () == LOC_OPTIMIZED_OUT)
     {
       PyErr_Format (PyExc_RuntimeError,
index ec8cdef052fd7940cb54ec52078cca7f26062029..7584d2572fae148e31e2f8de44fd896b7118c25a 100644 (file)
@@ -1511,7 +1511,7 @@ rust_structop::evaluate_funcall (struct type *expect_type,
   if (sym.symbol == NULL)
     error (_("Could not find function named '%s'"), name.c_str ());
 
-  struct type *fn_type = SYMBOL_TYPE (sym.symbol);
+  struct type *fn_type = sym.symbol->type ();
   if (fn_type->num_fields () == 0)
     error (_("Function '%s' takes no arguments"), name.c_str ());
 
index 75f8a3cf6ad61dea8fe7bdc53ef1354fa10f080c..1f75b4290c26bee8ceae75172946a73e59cd7edb 100644 (file)
@@ -458,7 +458,7 @@ rust_parser::rust_lookup_type (const char *name)
   if (result.symbol != NULL)
     {
       update_innermost_block (result);
-      return SYMBOL_TYPE (result.symbol);
+      return result.symbol->type ();
     }
 
   type = lookup_typename (language (), name, NULL, 1);
@@ -1218,7 +1218,7 @@ rust_parser::name_to_operation (const std::string &name)
   if (sym.symbol != nullptr)
     {
       gdb_assert (sym.symbol->aclass () == LOC_TYPEDEF);
-      type = SYMBOL_TYPE (sym.symbol);
+      type = sym.symbol->type ();
     }
   if (type == nullptr)
     type = rust_lookup_type (name.c_str ());
index 90092e8f309da48ff29cb45a91497247b8d051cf..03242ed9866f76bdbb38e70f269913ea32fbeeab 100644 (file)
@@ -1234,7 +1234,7 @@ sparc_frame_cache (struct frame_info *this_frame, void **this_cache)
 static int
 sparc32_struct_return_from_sym (struct symbol *sym)
 {
-  struct type *type = check_typedef (SYMBOL_TYPE (sym));
+  struct type *type = check_typedef (sym->type ());
   enum type_code code = type->code ();
 
   if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
index 33fcc9263f7eb473665b4860a6f341962c43f8e4..d3a1ae99069155ca0dc1e39c547d86839e3d0cfa 100644 (file)
@@ -434,12 +434,12 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
                  /* I don't think the linker does this with functions,
                     so as far as I know this is never executed.
                     But it doesn't hurt to check.  */
-                 SYMBOL_TYPE (sym) =
-                   lookup_function_type (read_type (&pp, objfile));
+                 sym->set_type
+                   (lookup_function_type (read_type (&pp, objfile)));
                }
              else
                {
-                 SYMBOL_TYPE (sym) = read_type (&pp, objfile);
+                 sym->set_type (read_type (&pp, objfile));
                }
              add_symbol_to_list (sym, get_global_symbols ());
            }
@@ -448,12 +448,12 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
              pp += 2;
              if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
                {
-                 SYMBOL_TYPE (sym) =
-                   lookup_function_type (read_type (&pp, objfile));
+                 sym->set_type
+                   (lookup_function_type (read_type (&pp, objfile)));
                }
              else
                {
-                 SYMBOL_TYPE (sym) = read_type (&pp, objfile);
+                 sym->set_type (read_type (&pp, objfile));
                }
            }
        }
@@ -784,7 +784,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       if (*p != '=')
        {
          sym->set_aclass_index (LOC_CONST);
-         SYMBOL_TYPE (sym) = error_type (&p, objfile);
+         sym->set_type (error_type (&p, objfile));
          sym->set_domain (VAR_DOMAIN);
          add_symbol_to_list (sym, get_file_symbols ());
          return sym;
@@ -804,7 +804,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
            target_float_from_string (dbl_valu, dbl_type, std::string (p));
 
-           SYMBOL_TYPE (sym) = dbl_type;
+           sym->set_type (dbl_type);
            SYMBOL_VALUE_BYTES (sym) = dbl_valu;
            sym->set_aclass_index (LOC_CONST_BYTES);
          }
@@ -818,7 +818,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
               types; other languages probably should have at least
               unsigned as well as signed constants.  */
 
-           SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_long;
+           sym->set_type (objfile_type (objfile)->builtin_long);
            SYMBOL_VALUE (sym) = atoi (p);
            sym->set_aclass_index (LOC_CONST);
          }
@@ -826,7 +826,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
        case 'c':
          {
-           SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_char;
+           sym->set_type (objfile_type (objfile)->builtin_char);
            SYMBOL_VALUE (sym) = atoi (p);
            sym->set_aclass_index (LOC_CONST);
          }
@@ -843,7 +843,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
            if (quote != '\'' && quote != '"')
              {
                sym->set_aclass_index (LOC_CONST);
-               SYMBOL_TYPE (sym) = error_type (&p, objfile);
+               sym->set_type (error_type (&p, objfile));
                sym->set_domain (VAR_DOMAIN);
                add_symbol_to_list (sym, get_file_symbols ());
                return sym;
@@ -868,7 +868,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
            if (*p != quote)
              {
                sym->set_aclass_index (LOC_CONST);
-               SYMBOL_TYPE (sym) = error_type (&p, objfile);
+               sym->set_type (error_type (&p, objfile));
                sym->set_domain (VAR_DOMAIN);
                add_symbol_to_list (sym, get_file_symbols ());
                return sym;
@@ -880,9 +880,9 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
              = create_static_range_type (NULL,
                                          objfile_type (objfile)->builtin_int,
                                          0, ind);
-           SYMBOL_TYPE (sym) = create_array_type (NULL,
-                                 objfile_type (objfile)->builtin_char,
-                                 range_type);
+           sym->set_type
+             (create_array_type (NULL, objfile_type (objfile)->builtin_char,
+                                 range_type));
            string_value
              = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, ind + 1);
            memcpy (string_value, string_local, ind + 1);
@@ -900,11 +900,11 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
             (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
          {
            sym->set_aclass_index (LOC_CONST);
-           SYMBOL_TYPE (sym) = read_type (&p, objfile);
+           sym->set_type (read_type (&p, objfile));
 
            if (*p != ',')
              {
-               SYMBOL_TYPE (sym) = error_type (&p, objfile);
+               sym->set_type (error_type (&p, objfile));
                break;
              }
            ++p;
@@ -921,7 +921,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
        default:
          {
            sym->set_aclass_index (LOC_CONST);
-           SYMBOL_TYPE (sym) = error_type (&p, objfile);
+           sym->set_type (error_type (&p, objfile));
          }
        }
       sym->set_domain (VAR_DOMAIN);
@@ -930,7 +930,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
     case 'C':
       /* The name of a caught exception.  */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (LOC_LABEL);
       sym->set_domain (VAR_DOMAIN);
       SET_SYMBOL_VALUE_ADDRESS (sym, valu);
@@ -939,7 +939,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
     case 'f':
       /* A static function definition.  */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (LOC_BLOCK);
       sym->set_domain (VAR_DOMAIN);
       add_symbol_to_list (sym, get_file_symbols ());
@@ -949,8 +949,8 @@ 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 (SYMBOL_TYPE (sym)->code () != TYPE_CODE_FUNC)
-       SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
+      if (sym->type ()->code () != TYPE_CODE_FUNC)
+       sym->set_type (lookup_function_type (sym->type ()));
 
       /* All functions in C++ have prototypes.  Stabs does not offer an
         explicit way to identify prototyped or unprototyped functions,
@@ -958,7 +958,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
         than the "declared-as" type for unprototyped functions, so
         we treat all functions as if they were prototyped.  This is used
         primarily for promotion when calling the function from GDB.  */
-      SYMBOL_TYPE (sym)->set_is_prototyped (true);
+      sym->type ()->set_is_prototyped (true);
 
       /* fall into process_prototype_types.  */
 
@@ -966,7 +966,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       /* Sun acc puts declared types of arguments here.  */
       if (*p == ';')
        {
-         struct type *ftype = SYMBOL_TYPE (sym);
+         struct type *ftype = sym->type ();
          int nsemi = 0;
          int nparams = 0;
          const char *p1 = p;
@@ -1011,7 +1011,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
     case 'F':
       /* A global function definition.  */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (LOC_BLOCK);
       sym->set_domain (VAR_DOMAIN);
       add_symbol_to_list (sym, get_global_symbols ());
@@ -1022,7 +1022,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
         value is not correct.  It is necessary to search for the
         corresponding linker definition to find the value.
         These definitions appear at the end of the namelist.  */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (LOC_STATIC);
       sym->set_domain (VAR_DOMAIN);
       /* Don't add symbol references to global_sym_chain.
@@ -1043,7 +1043,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
         Dbx data never actually contains 'l'.  */
     case 's':
     case 'l':
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (LOC_LOCAL);
       SYMBOL_VALUE (sym) = valu;
       sym->set_domain (VAR_DOMAIN);
@@ -1057,12 +1057,12 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
           Translate it into a pointer-to-function type.  */
        {
          p++;
-         SYMBOL_TYPE (sym)
-           lookup_pointer_type
-           (lookup_function_type (read_type (&p, objfile)));
+         sym->set_type
+           (lookup_pointer_type
+              (lookup_function_type (read_type (&p, objfile))));
        }
       else
-       SYMBOL_TYPE (sym) = read_type (&p, objfile);
+       sym->set_type (read_type (&p, objfile));
 
       sym->set_aclass_index (LOC_ARG);
       SYMBOL_VALUE (sym) = valu;
@@ -1086,12 +1086,12 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
        {
          /* If PCC says a parameter is a short or a char, it is
             really an int.  */
-         if (TYPE_LENGTH (SYMBOL_TYPE (sym))
+         if (TYPE_LENGTH (sym->type ())
              < gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT
-             && SYMBOL_TYPE (sym)->code () == TYPE_CODE_INT)
+             && sym->type ()->code () == TYPE_CODE_INT)
            {
-             SYMBOL_TYPE (sym) =
-               (SYMBOL_TYPE (sym)->is_unsigned ()
+             sym->set_type
+               (sym->type ()->is_unsigned ()
                 ? objfile_type (objfile)->builtin_unsigned_int
                 : objfile_type (objfile)->builtin_int);
            }
@@ -1105,14 +1105,14 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
         with this extra information.  FIXME, it ought to.  */
       if (type == N_FUN)
        {
-         SYMBOL_TYPE (sym) = read_type (&p, objfile);
+         sym->set_type (read_type (&p, objfile));
          goto process_prototype_types;
        }
       /*FALLTHROUGH */
 
     case 'R':
       /* Parameter which is in a register.  */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (stab_register_index);
       sym->set_is_argument (1);
       SYMBOL_VALUE (sym) = valu;
@@ -1122,7 +1122,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
     case 'r':
       /* Register variable (either global or local).  */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (stab_register_index);
       SYMBOL_VALUE (sym) = valu;
       sym->set_domain (VAR_DOMAIN);
@@ -1150,7 +1150,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
          struct pending *local_symbols = *get_local_symbols ();
          if (local_symbols
              && local_symbols->nsyms > 0
-             && gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
+             && gdbarch_stabs_argument_has_addr (gdbarch, sym->type ()))
            {
              struct symbol *prev_sym;
 
@@ -1163,7 +1163,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
                  prev_sym->set_aclass_index (stab_register_index);
                  /* Use the type from the LOC_REGISTER; that is the type
                     that is actually in that register.  */
-                 SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym);
+                 prev_sym->set_type (sym->type ());
                  SYMBOL_VALUE (prev_sym) = SYMBOL_VALUE (sym);
                  sym = prev_sym;
                  break;
@@ -1177,7 +1177,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
     case 'S':
       /* Static symbol at top level of file.  */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (LOC_STATIC);
       SET_SYMBOL_VALUE_ADDRESS (sym, valu);
       sym->set_domain (VAR_DOMAIN);
@@ -1202,7 +1202,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       synonym = (sym->language () == language_ada && p[-2] != 'T');
 
       /* Typedef */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
 
       /* For a nameless type, we don't want a create a symbol, thus we
         did not use `sym'.  Return without further processing.  */
@@ -1216,24 +1216,24 @@ 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 (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)))
+      if (sym->type ()->name () != NULL)
+       if ((sym->type ()->code () == TYPE_CODE_STRUCT
+            || sym->type ()->code () == TYPE_CODE_UNION)
+           && TYPE_N_BASECLASSES (sym->type ()))
          {
            int j;
 
-           for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
-             if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
-               SYMBOL_TYPE (sym)->field (j).set_name
-                 (TYPE_BASECLASS (SYMBOL_TYPE (sym), j)->name ());
+           for (j = TYPE_N_BASECLASSES (sym->type ()) - 1; j >= 0; j--)
+             if (TYPE_BASECLASS_NAME (sym->type (), j) == 0)
+               sym->type ()->field (j).set_name
+                 (TYPE_BASECLASS (sym->type (), j)->name ());
          }
 
-      if (SYMBOL_TYPE (sym)->name () == NULL)
+      if (sym->type ()->name () == NULL)
        {
-         if ((SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR
+         if ((sym->type ()->code () == TYPE_CODE_PTR
               && strcmp (sym->linkage_name (), vtbl_ptr_name))
-             || SYMBOL_TYPE (sym)->code () == TYPE_CODE_FUNC)
+             || sym->type ()->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
@@ -1272,10 +1272,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)
-               SYMBOL_TYPE (sym)->set_name (sym->linkage_name ());
+               sym->type ()->set_name (sym->linkage_name ());
            }
          else
-           SYMBOL_TYPE (sym)->set_name (sym->linkage_name ());
+           sym->type ()->set_name (sym->linkage_name ());
        }
 
       add_symbol_to_list (sym, get_file_symbols ());
@@ -1289,8 +1289,8 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
          struct_sym->set_aclass_index (LOC_TYPEDEF);
          SYMBOL_VALUE (struct_sym) = valu;
          struct_sym->set_domain (STRUCT_DOMAIN);
-         if (SYMBOL_TYPE (sym)->name () == 0)
-           SYMBOL_TYPE (sym)->set_name
+         if (sym->type ()->name () == 0)
+           sym->type ()->set_name
              (obconcat (&objfile->objfile_obstack, sym->linkage_name (),
                         (char *) NULL));
          add_symbol_to_list (struct_sym, get_file_symbols ());
@@ -1306,7 +1306,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       if (synonym)
        p++;
 
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
  
       /* For a nameless type, we don't want a create a symbol, thus we
         did not use `sym'.  Return without further processing.  */
@@ -1316,8 +1316,8 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       sym->set_aclass_index (LOC_TYPEDEF);
       SYMBOL_VALUE (sym) = valu;
       sym->set_domain (STRUCT_DOMAIN);
-      if (SYMBOL_TYPE (sym)->name () == 0)
-       SYMBOL_TYPE (sym)->set_name
+      if (sym->type ()->name () == 0)
+       sym->type ()->set_name
          (obconcat (&objfile->objfile_obstack, sym->linkage_name (),
                     (char *) NULL));
       add_symbol_to_list (sym, get_file_symbols ());
@@ -1331,8 +1331,8 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
          typedef_sym->set_aclass_index (LOC_TYPEDEF);
          SYMBOL_VALUE (typedef_sym) = valu;
          typedef_sym->set_domain (VAR_DOMAIN);
-         if (SYMBOL_TYPE (sym)->name () == 0)
-           SYMBOL_TYPE (sym)->set_name
+         if (sym->type ()->name () == 0)
+           sym->type ()->set_name
              (obconcat (&objfile->objfile_obstack, sym->linkage_name (),
                         (char *) NULL));
          add_symbol_to_list (typedef_sym, get_file_symbols ());
@@ -1341,7 +1341,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
     case 'V':
       /* Static symbol of local scope.  */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (LOC_STATIC);
       SET_SYMBOL_VALUE_ADDRESS (sym, valu);
       sym->set_domain (VAR_DOMAIN);
@@ -1350,7 +1350,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
     case 'v':
       /* Reference parameter */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (LOC_REF_ARG);
       sym->set_is_argument (1);
       SYMBOL_VALUE (sym) = valu;
@@ -1360,7 +1360,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
     case 'a':
       /* Reference parameter which is in a register.  */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (stab_regparm_index);
       sym->set_is_argument (1);
       SYMBOL_VALUE (sym) = valu;
@@ -1373,7 +1373,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
         Sun claims ("dbx and dbxtool interfaces", 2nd ed)
         that Pascal uses it too, but when I tried it Pascal used
         "x:3" (local symbol) instead.  */
-      SYMBOL_TYPE (sym) = read_type (&p, objfile);
+      sym->set_type (read_type (&p, objfile));
       sym->set_aclass_index (LOC_LOCAL);
       SYMBOL_VALUE (sym) = valu;
       sym->set_domain (VAR_DOMAIN);
@@ -1381,7 +1381,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       break;
 
     default:
-      SYMBOL_TYPE (sym) = error_type (&p, objfile);
+      sym->set_type (error_type (&p, objfile));
       sym->set_aclass_index (LOC_CONST);
       SYMBOL_VALUE (sym) = 0;
       sym->set_domain (VAR_DOMAIN);
@@ -1393,7 +1393,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
      of by value, i.e. they will pass the address of a structure (in a
      register or on the stack) instead of the structure itself.  */
 
-  if (gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym))
+  if (gdbarch_stabs_argument_has_addr (gdbarch, sym->type ())
       && sym->is_argument ())
     {
       /* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
@@ -1630,11 +1630,11 @@ again:
 
              if (sym->aclass () == LOC_TYPEDEF
                  && sym->domain () == STRUCT_DOMAIN
-                 && (SYMBOL_TYPE (sym)->code () == code)
+                 && (sym->type ()->code () == code)
                  && strcmp (sym->linkage_name (), type_name) == 0)
                {
                  obstack_free (&objfile->objfile_obstack, type_name);
-                 type = SYMBOL_TYPE (sym);
+                 type = sym->type ();
                  if (typenums[0] != -1)
                    *dbx_lookup_type (typenums, objfile) = type;
                  return type;
@@ -3635,7 +3635,7 @@ read_enum_type (const char **pp, struct type *type,
        {
          struct symbol *xsym = syms->symbol[j];
 
-         SYMBOL_TYPE (xsym) = type;
+         xsym->set_type (type);
          type->field (n).set_name (xsym->linkage_name ());
          type->field (n).set_loc_enumval (SYMBOL_VALUE (xsym));
          TYPE_FIELD_BITSIZE (type, n) = 0;
@@ -4281,7 +4281,7 @@ common_block_end (struct objfile *objfile)
     for (j = common_block_i; j < common_block->nsyms; j++)
       add_symbol_to_list (common_block->symbol[j], &newobj);
 
-  SYMBOL_TYPE (sym) = (struct type *) newobj;
+  sym->set_type ((struct type *) newobj);
 
   /* Should we be putting local_symbols back to what it was?
      Does it matter?  */
@@ -4299,7 +4299,7 @@ common_block_end (struct objfile *objfile)
 static void
 fix_common_block (struct symbol *sym, CORE_ADDR valu)
 {
-  struct pending *next = (struct pending *) SYMBOL_TYPE (sym);
+  struct pending *next = (struct pending *) sym->type ();
 
   for (; next; next = next->next)
     {
@@ -4468,11 +4468,11 @@ cleanup_undefined_types_1 (void)
 
                        if (sym->aclass () == LOC_TYPEDEF
                            && sym->domain () == STRUCT_DOMAIN
-                           && (SYMBOL_TYPE (sym)->code () == (*type)->code ())
+                           && (sym->type ()->code () == (*type)->code ())
                            && ((*type)->instance_flags ()
-                               == SYMBOL_TYPE (sym)->instance_flags ())
+                               == sym->type ()->instance_flags ())
                            && strcmp (sym->linkage_name (), type_name) == 0)
-                         replace_type (*type, SYMBOL_TYPE (sym));
+                         replace_type (*type, sym->type ());
                      }
                  }
              }
index 834e016ef937e0a5f9a8fdd538ba34f049c703a2..b1bbf7d0f4493805da4c34cb3afd0f5cdbf174f3 100644 (file)
@@ -674,7 +674,7 @@ read_frame_arg (const frame_print_options &fp_opts,
          || (fp_opts.print_entry_values == print_entry_values_preferred
              && (!val || value_optimized_out (val))))
        {
-         entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
+         entryval = allocate_optimized_out_value (sym->type ());
          entryval_error = NULL;
        }
     }
@@ -779,7 +779,7 @@ print_frame_args (const frame_print_options &fp_opts,
            case LOC_REF_ARG:
              {
                long current_offset = SYMBOL_VALUE (sym);
-               int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
+               int arg_size = TYPE_LENGTH (sym->type ());
 
                /* Compute address of next argument by adding the size of
                   this argument and rounding to an int boundary.  */
@@ -2762,7 +2762,7 @@ return_command (const char *retval_exp, int from_tty)
       /* Cast return value to the return type of the function.  Should
         the cast fail, this call throws an error.  */
       if (thisfun != NULL)
-       return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
+       return_type = TYPE_TARGET_TYPE (thisfun->type ());
       if (return_type == NULL)
        {
          if (retval_expr->first_opcode () != UNOP_CAST
@@ -2818,7 +2818,7 @@ return_command (const char *retval_exp, int from_tty)
                           query_prefix);
       else
        {
-         if (TYPE_NO_RETURN (thisfun->type))
+         if (TYPE_NO_RETURN (thisfun->type ()))
            warning (_("Function does not return normally to caller."));
          confirmed = query (_("%sMake %s return now? "), query_prefix,
                             thisfun->print_name ());
index 328230afe3ad59f1236db0eadd458f3a72243985..160278b50a97f823b7c8213860c766aba1861d2b 100644 (file)
@@ -523,20 +523,20 @@ print_symbol (struct gdbarch *gdbarch, struct symbol *symbol,
 
   if (symbol->domain () == STRUCT_DOMAIN)
     {
-      if (SYMBOL_TYPE (symbol)->name ())
+      if (symbol->type ()->name ())
        {
-         LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
+         LA_PRINT_TYPE (symbol->type (), "", outfile, 1, depth,
                         &type_print_raw_options);
        }
       else
        {
          fprintf_filtered (outfile, "%s %s = ",
-                        (SYMBOL_TYPE (symbol)->code () == TYPE_CODE_ENUM
+                        (symbol->type ()->code () == TYPE_CODE_ENUM
                          ? "enum"
-                    : (SYMBOL_TYPE (symbol)->code () == TYPE_CODE_STRUCT
+                    : (symbol->type ()->code () == TYPE_CODE_STRUCT
                        ? "struct" : "union")),
                            symbol->linkage_name ());
-         LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
+         LA_PRINT_TYPE (symbol->type (), "", outfile, 1, depth,
                         &type_print_raw_options);
        }
       fprintf_filtered (outfile, ";\n");
@@ -545,12 +545,12 @@ print_symbol (struct gdbarch *gdbarch, struct symbol *symbol,
     {
       if (symbol->aclass () == LOC_TYPEDEF)
        fprintf_filtered (outfile, "typedef ");
-      if (SYMBOL_TYPE (symbol))
+      if (symbol->type ())
        {
          /* Print details of types, except for enums where it's clutter.  */
-         LA_PRINT_TYPE (SYMBOL_TYPE (symbol), symbol->print_name (),
+         LA_PRINT_TYPE (symbol->type (), symbol->print_name (),
                         outfile,
-                        SYMBOL_TYPE (symbol)->code () != TYPE_CODE_ENUM,
+                        symbol->type ()->code () != TYPE_CODE_ENUM,
                         depth,
                         &type_print_raw_options);
          fprintf_filtered (outfile, "; ");
@@ -569,7 +569,7 @@ print_symbol (struct gdbarch *gdbarch, struct symbol *symbol,
        case LOC_CONST_BYTES:
          {
            unsigned i;
-           struct type *type = check_typedef (SYMBOL_TYPE (symbol));
+           struct type *type = check_typedef (symbol->type ());
 
            fprintf_filtered (outfile, "const %s hex bytes:",
                              pulongest (TYPE_LENGTH (type)));
index 8bdc6cab9608c337ab24af4249ae2544d6b4bd22..8da86b61359568244f10507de4277de56e1739d2 100644 (file)
@@ -2130,7 +2130,7 @@ lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
 
       if (result.symbol)
        {
-         struct type *t = result.symbol->type;
+         struct type *t = result.symbol->type ();
 
          /* I'm not really sure that type of this can ever
             be typedefed; just be safe.  */
@@ -2806,8 +2806,8 @@ basic_lookup_transparent_type_quick (struct objfile *objfile,
                           block_find_non_opaque_type, NULL);
   if (sym == NULL)
     error_in_psymtab_expansion (block_index, name, cust);
-  gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
-  return SYMBOL_TYPE (sym);
+  gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
+  return sym->type ();
 }
 
 /* Subroutine of basic_lookup_transparent_type to simplify it.
@@ -2831,8 +2831,8 @@ basic_lookup_transparent_type_1 (struct objfile *objfile,
                               block_find_non_opaque_type, NULL);
       if (sym != NULL)
        {
-         gdb_assert (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)));
-         return SYMBOL_TYPE (sym);
+         gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
+         return sym->type ();
        }
     }
 
@@ -4657,7 +4657,7 @@ treg_matches_sym_type_name (const compiled_regex &treg,
                          sym->natural_name ());
     }
 
-  sym_type = SYMBOL_TYPE (sym);
+  sym_type = sym->type ();
   if (sym_type == NULL)
     return false;
 
@@ -4836,7 +4836,7 @@ global_symbol_searcher::add_matching_symbols
                              members.  We only want to skip enums
                              here.  */
                           && !(sym->aclass () == LOC_CONST
-                               && (SYMBOL_TYPE (sym)->code ()
+                               && (sym->type ()->code ()
                                    == TYPE_CODE_ENUM))
                           && (!treg.has_value ()
                               || treg_matches_sym_type_name (*treg, sym)))
@@ -5042,10 +5042,10 @@ symbol_to_info_string (struct symbol *sym, int block,
         For the struct printing case below, things are worse, we force
         printing of the ";" in this function, which is going to be wrong
         for languages that don't require a ";" between statements.  */
-      if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_TYPEDEF)
-       typedef_print (SYMBOL_TYPE (sym), sym, &tmp_stream);
+      if (sym->type ()->code () == TYPE_CODE_TYPEDEF)
+       typedef_print (sym->type (), sym, &tmp_stream);
       else
-       type_print (SYMBOL_TYPE (sym), "", &tmp_stream, -1);
+       type_print (sym->type (), "", &tmp_stream, -1);
       str += tmp_stream.string ();
     }
   /* variable, func, or typedef-that-is-c++-class.  */
@@ -5055,7 +5055,7 @@ symbol_to_info_string (struct symbol *sym, int block,
     {
       string_file tmp_stream;
 
-      type_print (SYMBOL_TYPE (sym),
+      type_print (sym->type (),
                  (sym->aclass () == LOC_TYPEDEF
                   ? "" : sym->print_name ()),
                  &tmp_stream, 0);
@@ -5673,7 +5673,7 @@ completion_list_add_fields (completion_tracker &tracker,
 {
   if (sym->aclass () == LOC_TYPEDEF)
     {
-      struct type *t = SYMBOL_TYPE (sym);
+      struct type *t = sym->type ();
       enum type_code c = t->code ();
       int j;
 
@@ -5691,7 +5691,7 @@ completion_list_add_fields (completion_tracker &tracker,
 bool
 symbol_is_function_or_method (symbol *sym)
 {
-  switch (SYMBOL_TYPE (sym)->code ())
+  switch (sym->type ()->code ())
     {
     case TYPE_CODE_FUNC:
     case TYPE_CODE_METHOD:
@@ -5789,7 +5789,7 @@ add_symtab_completions (struct compunit_symtab *cust,
 
          if (code == TYPE_CODE_UNDEF
              || (sym->domain () == STRUCT_DOMAIN
-                 && SYMBOL_TYPE (sym)->code () == code))
+                 && sym->type ()->code () == code))
            completion_list_add_symbol (tracker, sym,
                                        lookup_name,
                                        text, word);
@@ -5942,7 +5942,7 @@ default_collect_symbol_completion_matches_break_on
                                            sym_text, word);
              }
            else if (sym->domain () == STRUCT_DOMAIN
-                    && SYMBOL_TYPE (sym)->code () == code)
+                    && sym->type ()->code () == code)
              completion_list_add_symbol (tracker, sym, lookup_name,
                                          sym_text, word);
          }
index a86145198fdca0b4e94fca62cb787031f8c20de5..3486803cca8e679dd03b6c69c28795d0301cbaeb 100644 (file)
@@ -1203,9 +1203,19 @@ struct symbol : public general_symbol_info, public allocate_on_obstack
     return this->subclass == SYMBOL_TEMPLATE;
   }
 
+  struct type *type () const
+  {
+    return m_type;
+  }
+
+  void set_type (struct type *type)
+  {
+    m_type = type;
+  }
+
   /* Data type of value */
 
-  struct type *type = nullptr;
+  struct type *m_type = nullptr;
 
   /* The owner of this symbol.
      Which one to use is defined by symbol.is_objfile_owned.  */
@@ -1305,7 +1315,6 @@ struct block_symbol
 /* Note: There is no accessor macro for symbol.owner because it is
    "private".  */
 
-#define SYMBOL_TYPE(symbol)            (symbol)->type
 #define SYMBOL_LINE(symbol)            (symbol)->line
 #define SYMBOL_COMPUTED_OPS(symbol)    ((symbol)->impl ().ops_computed)
 #define SYMBOL_BLOCK_OPS(symbol)       ((symbol)->impl ().ops_block)
index d8577dc4518bfe16fd305cee6c4b24b0f8484c11..73ebc38eb805cf61d6a37f25feaf331690456ebd 100644 (file)
@@ -927,7 +927,7 @@ collection_list::collect_symbol (struct symbol *sym,
   bfd_signed_vma offset;
   int treat_as_expr = 0;
 
-  len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
+  len = TYPE_LENGTH (check_typedef (sym->type ()));
   switch (sym->aclass ())
     {
     default:
@@ -948,7 +948,7 @@ collection_list::collect_symbol (struct symbol *sym,
        }
       /* A struct may be a C++ class with static fields, go to general
         expression handling.  */
-      if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_STRUCT)
+      if (sym->type ()->code () == TYPE_CODE_STRUCT)
        treat_as_expr = 1;
       else
        add_memrange (gdbarch, memrange_absolute, offset, len, scope);
@@ -960,7 +960,7 @@ collection_list::collect_symbol (struct symbol *sym,
       add_local_register (gdbarch, reg, scope);
       /* Check for doubles stored in two registers.  */
       /* FIXME: how about larger types stored in 3 or more regs?  */
-      if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_FLT &&
+      if (sym->type ()->code () == TYPE_CODE_FLT &&
          len > register_size (gdbarch, reg))
        add_local_register (gdbarch, reg + 1, scope);
       break;
@@ -2565,8 +2565,8 @@ info_scope_command (const char *args_in, int from_tty)
                  break;
                case LOC_CONST_BYTES:
                  printf_filtered ("constant bytes: ");
-                 if (SYMBOL_TYPE (sym))
-                   for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
+                 if (sym->type ())
+                   for (j = 0; j < TYPE_LENGTH (sym->type ()); j++)
                      printf_filtered (" %02x",
                                       (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
                  break;
@@ -2645,9 +2645,9 @@ info_scope_command (const char *args_in, int from_tty)
                  gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
                }
            }
-         if (SYMBOL_TYPE (sym))
+         if (sym->type ())
            {
-             struct type *t = check_typedef (SYMBOL_TYPE (sym));
+             struct type *t = check_typedef (sym->type ());
 
              printf_filtered (", length %s.\n", pulongest (TYPE_LENGTH (t)));
            }
index 1de223ac5a108f701a74eca5d09686272a59023a..f7a2ebac398fc1832ac238d037ee333815220f1c 100644 (file)
@@ -260,7 +260,7 @@ typedef_hash_table::add_template_parameters (struct type *t)
 
       tf = XOBNEW (&m_storage, struct decl_field);
       tf->name = TYPE_TEMPLATE_ARGUMENT (t, i)->linkage_name ();
-      tf->type = SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t, i));
+      tf->type = TYPE_TEMPLATE_ARGUMENT (t, i)->type ();
 
       slot = htab_find_slot (m_table.get (), tf, INSERT);
       if (*slot == NULL)
index 9767b2c30e695e9368b8605f97d0a3bdc99a8e92..3a595125752f0d0c3bef1ee40a62ca36e447fa62 100644 (file)
@@ -1387,7 +1387,7 @@ value_of_variable (struct symbol *var, const struct block *b)
 struct value *
 address_of_variable (struct symbol *var, const struct block *b)
 {
-  struct type *type = SYMBOL_TYPE (var);
+  struct type *type = var->type ();
   struct value *val;
 
   /* Evaluate it first; if the result is a memory address, we're fine.
@@ -2833,7 +2833,7 @@ find_overload_match (gdb::array_view<value *> args,
             the function part.  Do not try this for non-functions (e.g.
             function pointers).  */
          if (qualified_name
-             && (check_typedef (SYMBOL_TYPE (fsym))->code ()
+             && (check_typedef (fsym->type ())->code ()
                  == TYPE_CODE_FUNC))
            {
              temp_func = cp_func_name (qualified_name);
@@ -3187,14 +3187,14 @@ find_oload_champ (gdb::array_view<value *> args,
              static_offset = oload_method_static_p (methods, ix);
            }
          else
-           nparms = SYMBOL_TYPE (functions[ix])->num_fields ();
+           nparms = functions[ix]->type ()->num_fields ();
 
          parm_types.reserve (nparms);
          for (jj = 0; jj < nparms; jj++)
            {
              type *t = (methods != NULL
                         ? (TYPE_FN_FIELD_ARGS (methods, ix)[jj].type ())
-                        : SYMBOL_TYPE (functions[ix])->field (jj).type ());
+                        : functions[ix]->type ()->field (jj).type ());
              parm_types.push_back (t);
            }
        }
@@ -3780,7 +3780,7 @@ value_maybe_namespace_elt (const struct type *curtype,
     return NULL;
   else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
           && (sym.symbol->aclass () == LOC_TYPEDEF))
-    result = allocate_value (SYMBOL_TYPE (sym.symbol));
+    result = allocate_value (sym.symbol->type ());
   else
     result = value_of_variable (sym.symbol, sym.block);
 
index bdfbdbff96ff8008057f13489dafc5f5ae5be436..d3e9ade72cb57768b61d3dd374ed482ce38b27c7 100644 (file)
@@ -1572,7 +1572,7 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile)
         patch_block_stabs (), unless the file was compiled without -g.  */
 
       sym->set_linkage_name (SYMNAME_ALLOC (name, symname_alloced));
-      SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_text_symbol;
+      sym->set_type (objfile_type (objfile)->nodebug_text_symbol);
 
       sym->set_aclass_index (LOC_BLOCK);
       sym2 = new (&objfile->objfile_obstack) symbol (*sym);
@@ -1585,7 +1585,7 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile)
   else
     {
       /* In case we can't figure out the type, provide default.  */
-      SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_data_symbol;
+      sym->set_type (objfile_type (objfile)->nodebug_data_symbol);
 
       switch (cs->c_sclass)
        {
This page took 0.18312 seconds and 4 git commands to generate.