Replace symbol_symtab with symbol::symtab

This turns symbol_symtab into a method on symbol.  It also replaces
symbol_set_symtab with a method.

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 96494538a605f44a956a1c6cb45c8bde6b9f606d..bb9a16f8fe07ad1fe9d4e0d5b8dc3b74163889f2 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -3681,7 +3681,7 @@ See set/show multiple-symbol."));
          struct symtab *symtab = NULL;
 
          if (syms[i].symbol->is_objfile_owned ())
-           symtab = symbol_symtab (syms[i].symbol);
+           symtab = syms[i].symbol->symtab ();
 
          if (syms[i].symbol->line () != 0 && symtab != NULL)
            {
@@ -4712,9 +4712,9 @@ cache_symbol (const char *name, domain_enum domain, struct symbol *sym,
      the symbol is local or not, we check the block where we found it
      against the global and static blocks of its associated symtab.  */
   if (sym
-      && BLOCKVECTOR_BLOCK (symbol_symtab (sym)->compunit ()->blockvector (),
+      && BLOCKVECTOR_BLOCK (sym->symtab ()->compunit ()->blockvector (),
                            GLOBAL_BLOCK) != block
-      && BLOCKVECTOR_BLOCK (symbol_symtab (sym)->compunit ()->blockvector (),
+      && BLOCKVECTOR_BLOCK (sym->symtab ()->compunit ()->blockvector (),
                            STATIC_BLOCK) != block)
     return;
 

diff --git a/gdb/btrace.c b/gdb/btrace.c
index b195b59a7c379486fe6b6dc692298a5fe2863cda..c4f0d4911ab7a2b59e9539539f05a2b689044b8d 100644 (file)
--- a/gdb/btrace.c
+++ b/gdb/btrace.c
@@ -102,7 +102,7 @@ ftrace_print_filename (const struct btrace_function *bfun)
   sym = bfun->sym;
 
   if (sym != NULL)
-    filename = symtab_to_filename_for_display (symbol_symtab (sym));
+    filename = symtab_to_filename_for_display (sym->symtab ());
   else
     filename = "<unknown>";
 
@@ -210,8 +210,8 @@ ftrace_function_switched (const struct btrace_function *bfun,
        return 1;
 
       /* Check the location of those functions, as well.  */
-      bfname = symtab_to_fullname (symbol_symtab (sym));
-      fname = symtab_to_fullname (symbol_symtab (fun));
+      bfname = symtab_to_fullname (sym->symtab ());
+      fname = symtab_to_fullname (fun->symtab ());
       if (filename_cmp (fname, bfname) != 0)
        return 1;
     }

diff --git a/gdb/buildsym.c b/gdb/buildsym.c
index 628903d674f4ad7b0551cd1f7d3761214b773ea4..927074b76691e0efb322f51a57d1f4b26dcd0533 100644 (file)
--- a/gdb/buildsym.c
+++ b/gdb/buildsym.c
@@ -1006,15 +1006,15 @@ buildsym_compunit::end_compunit_symtab_with_blockvector
        /* Inlined functions may have symbols not in the global or
           static symbol lists.  */
        if (BLOCK_FUNCTION (block) != NULL)
-         if (symbol_symtab (BLOCK_FUNCTION (block)) == NULL)
-           symbol_set_symtab (BLOCK_FUNCTION (block), symtab);
+         if (BLOCK_FUNCTION (block)->symtab () == NULL)
+           BLOCK_FUNCTION (block)->set_symtab (symtab);
 
        /* Note that we only want to fix up symbols from the local
           blocks, not blocks coming from included symtabs.  That is why
           we use ALL_DICT_SYMBOLS here and not ALL_BLOCK_SYMBOLS.  */
        ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
-         if (symbol_symtab (sym) == NULL)
-           symbol_set_symtab (sym, symtab);
+         if (sym->symtab () == NULL)
+           sym->set_symtab (symtab);
       }
   }
 
@@ -1114,8 +1114,8 @@ set_missing_symtab (struct pending *pending_list,
     {
       for (i = 0; i < pending->nsyms; ++i)
        {
-         if (symbol_symtab (pending->symbol[i]) == NULL)
-           symbol_set_symtab (pending->symbol[i], cu->primary_filetab ());
+         if (pending->symbol[i]->symtab () == NULL)
+           pending->symbol[i]->set_symtab (cu->primary_filetab ());
        }
     }
 }

diff --git a/gdb/compile/compile-c-symbols.c b/gdb/compile/compile-c-symbols.c
index 642c0be5db32492ca6b676a651be5d130522fe6b..d49ecdab92f380792f2deaf64efc4793048e6e26 100644 (file)
--- a/gdb/compile/compile-c-symbols.c
+++ b/gdb/compile/compile-c-symbols.c
@@ -57,7 +57,7 @@ convert_one_symbol (compile_c_instance *context,
                    int is_local)
 {
   gcc_type sym_type;
-  const char *filename = symbol_symtab (sym.symbol)->filename;
+  const char *filename = sym.symbol->symtab ()->filename;
   unsigned short line = sym.symbol->line ();
 
   context->error_symbol_once (sym.symbol);

diff --git a/gdb/compile/compile-cplus-symbols.c b/gdb/compile/compile-cplus-symbols.c
index 7ad9ea91132d990c0edda3d8a5488fede65682c9..95d43507c30ebec49a6c122c5cf15fa285255333 100644 (file)
--- a/gdb/compile/compile-cplus-symbols.c
+++ b/gdb/compile/compile-cplus-symbols.c
@@ -48,7 +48,7 @@ convert_one_symbol (compile_cplus_instance *instance,
 {
   /* Squash compiler warning.  */
   gcc_type sym_type = 0;
-  const char *filename = symbol_symtab (sym.symbol)->filename;
+  const char *filename = sym.symbol->symtab ()->filename;
   unsigned short line = sym.symbol->line ();
 
   instance->error_symbol_once (sym.symbol);

diff --git a/gdb/compile/compile-cplus-types.c b/gdb/compile/compile-cplus-types.c
index cea30304aa241976b01e74599c0fd95b59a2e2f2..ab65e47f49d6ab14c133753ccf1ccd3862c89e44 100644 (file)
--- a/gdb/compile/compile-cplus-types.c
+++ b/gdb/compile/compile-cplus-types.c
@@ -625,7 +625,7 @@ compile_cplus_convert_struct_or_union_members
                       we can do but ignore this member.  */
                    continue;
                  }
-               const char *filename = symbol_symtab (sym.symbol)->filename;
+               const char *filename = sym.symbol->symtab ()->filename;
                unsigned int line = sym.symbol->line ();
 
                physaddr = sym.symbol->value_address ();
@@ -764,7 +764,7 @@ compile_cplus_convert_struct_or_union_methods (compile_cplus_instance *instance,
              continue;
            }
 
-         const char *filename = symbol_symtab (sym.symbol)->filename;
+         const char *filename = sym.symbol->symtab ()->filename;
          unsigned int line = sym.symbol->line ();
          CORE_ADDR address = BLOCK_START (sym.symbol->value_block ());
          const char *kind;

diff --git a/gdb/compile/compile-object-load.c b/gdb/compile/compile-object-load.c
index 7da02c07f9b2790aca2e102e37942898591e76e3..2303381b49af09a7e325b7cfe161c3f92fe08b8a 100644 (file)
--- a/gdb/compile/compile-object-load.c
+++ b/gdb/compile/compile-object-load.c
@@ -421,7 +421,7 @@ get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
   lookup_name_info func_matcher (GCC_FE_WRAPPER_FUNCTION,
                                 symbol_name_match_type::SEARCH_NAME);
 
-  bv = symbol_symtab (func_sym)->compunit ()->blockvector ();
+  bv = func_sym->symtab ()->compunit ()->blockvector ();
   nblocks = BLOCKVECTOR_NBLOCKS (bv);
 
   gdb_ptr_type_sym = NULL;

diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index b7b372fcd73cb6c20bb9df67e55b514dd7b5e239..bb72e0e4791b1fda071ff8c64d6e016b95ccb2df 100644 (file)
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -7810,9 +7810,9 @@ fixup_go_packaging (struct dwarf2_cu *cu)
                  struct objfile *objfile = cu->per_objfile->objfile;
                  if (strcmp (package_name.get (), this_package_name.get ()) != 0)
                    complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
-                              (symbol_symtab (sym) != NULL
+                              (sym->symtab () != NULL
                                ? symtab_to_filename_for_display
-                                   (symbol_symtab (sym))
+                               (sym->symtab ())
                                : objfile_name (objfile)),
                               this_package_name.get (), package_name.get ());
                }
@@ -12081,7 +12081,7 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
         of gdb assume that symbols do, and this is reasonably
         true.  */
       for (symbol *sym : template_args)
-       symbol_set_symtab (sym, symbol_symtab (templ_func));
+       sym->set_symtab (templ_func->symtab ());
     }
 
   /* In C++, we can have functions nested inside functions (e.g., when
@@ -14977,7 +14977,7 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
        {
          struct symtab *symtab;
          if (sym != nullptr)
-           symtab = symbol_symtab (sym);
+           symtab = sym->symtab ();
          else if (cu->line_header != nullptr)
            {
              /* Any related symtab will do.  */
@@ -15001,7 +15001,7 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
                 other parts of gdb assume that symbols do, and this is
                 reasonably true.  */
              for (int i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
-               symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type, i), symtab);
+               TYPE_TEMPLATE_ARGUMENT (type, i)->set_symtab (symtab);
            }
        }
     }
@@ -20667,7 +20667,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
          if (fe == NULL)
            complaint (_("file index out of range"));
          else
-           symbol_set_symtab (sym, fe->symtab);
+           sym->set_symtab (fe->symtab);
        }
 
       switch (die->tag)

diff --git a/gdb/frame.c b/gdb/frame.c
index 2e574a2f009c2dc7a10e366d819fd3b4ec047e83..5e3c02e2029b915e164e5aadad89926524e0ebfd 100644 (file)
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -2701,7 +2701,7 @@ find_frame_sal (frame_info *frame)
       symtab_and_line sal;
       if (sym->line () != 0)
        {
-         sal.symtab = symbol_symtab (sym);
+         sal.symtab = sym->symtab ();
          sal.line = sym->line ();
        }
       else

diff --git a/gdb/guile/scm-symbol.c b/gdb/guile/scm-symbol.c
index 9e89b0458af16a43fe9f1111384a62e1596cc79e..55eac3cfff69dbdbcbb539d16f96bf2af776fea2 100644 (file)
--- a/gdb/guile/scm-symbol.c
+++ b/gdb/guile/scm-symbol.c
@@ -364,7 +364,7 @@ gdbscm_symbol_symtab (SCM self)
 
   if (!symbol->is_objfile_owned ())
     return SCM_BOOL_F;
-  return stscm_scm_from_symtab (symbol_symtab (symbol));
+  return stscm_scm_from_symtab (symbol->symtab ());
 }
 
 /* (symbol-name <gdb:symbol>) -> string */

diff --git a/gdb/jit.c b/gdb/jit.c
index ae679a1f0437b34853dc67741d8decb3a9ecb63d..f7e25e494d448b6f62e7a789cb21b2450393b642 100644 (file)
--- a/gdb/jit.c
+++ b/gdb/jit.c
@@ -589,7 +589,7 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
       /* The name.  */
       block_name->set_domain (VAR_DOMAIN);
       block_name->set_aclass_index (LOC_BLOCK);
-      symbol_set_symtab (block_name, filetab);
+      block_name->set_symtab (filetab);
       block_name->set_type (lookup_function_type (block_type));
       block_name->set_value_block (new_block);
 

diff --git a/gdb/linespec.c b/gdb/linespec.c
index ba89bd09b56094d60c3822527f8f81519e2401ce..61ad69dd882d65b05b3ae68f8ac1b38ce22c51b6 100644 (file)
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -2188,7 +2188,7 @@ convert_linespec_to_sals (struct linespec_state *state, linespec *ls)
       for (const auto &sym : ls->labels.label_symbols)
        {
          struct program_space *pspace
-           = symbol_symtab (sym.symbol)->compunit ()->objfile ()->pspace;
+           = sym.symbol->symtab ()->compunit ()->objfile ()->pspace;
 
          if (symbol_to_sal (&sal, state->funfirstline, sym.symbol)
              && maybe_add_address (state->addr_set, pspace, sal.pc))
@@ -2210,7 +2210,7 @@ convert_linespec_to_sals (struct linespec_state *state, linespec *ls)
          for (const auto &sym : ls->function_symbols)
            {
              program_space *pspace
-               = symbol_symtab (sym.symbol)->compunit ()->objfile ()->pspace;
+               = sym.symbol->symtab ()->compunit ()->objfile ()->pspace;
              set_current_program_space (pspace);
 
              /* Don't skip to the first line of the function if we
@@ -3483,8 +3483,8 @@ compare_symbols (const block_symbol &a, const block_symbol &b)
 {
   uintptr_t uia, uib;
 
-  uia = (uintptr_t) symbol_symtab (a.symbol)->compunit ()->objfile ()->pspace;
-  uib = (uintptr_t) symbol_symtab (b.symbol)->compunit ()->objfile ()->pspace;
+  uia = (uintptr_t) a.symbol->symtab ()->compunit ()->objfile ()->pspace;
+  uib = (uintptr_t) b.symbol->symtab ()->compunit ()->objfile ()->pspace;
 
   if (uia < uib)
     return true;
@@ -3608,7 +3608,7 @@ find_method (struct linespec_state *self,
 
       /* Program spaces that are executing startup should have
         been filtered out earlier.  */
-      pspace = symbol_symtab (sym)->compunit ()->objfile ()->pspace;
+      pspace = sym->symtab ()->compunit ()->objfile ()->pspace;
       gdb_assert (!pspace->executing_startup);
       set_current_program_space (pspace);
       t = check_typedef (sym->type ());
@@ -3619,7 +3619,7 @@ find_method (struct linespec_state *self,
         sure not to miss the last batch.  */
       if (ix == sym_classes->size () - 1
          || (pspace
-             != (symbol_symtab (sym_classes->at (ix + 1).symbol)
+             != (sym_classes->at (ix + 1).symbol->symtab ()
                  ->compunit ()->objfile ()->pspace)))
        {
          /* If we did not find a direct implementation anywhere in
@@ -3985,7 +3985,7 @@ find_label_symbols (struct linespec_state *self,
        {
          fn_sym = elt.symbol;
          set_current_program_space
-           (symbol_symtab (fn_sym)->compunit ()->objfile ()->pspace);
+           (fn_sym->symtab ()->compunit ()->objfile ()->pspace);
          block = fn_sym->value_block ();
 
          find_label_symbols_in_block (block, name, fn_sym, completion_mode,
@@ -4380,7 +4380,7 @@ symbol_to_sal (struct symtab_and_line *result,
       if (sym->aclass () == LOC_LABEL && sym->value_address () != 0)
        {
          *result = {};
-         result->symtab = symbol_symtab (sym);
+         result->symtab = sym->symtab ();
          result->symbol = sym;
          result->line = sym->line ();
          result->pc = sym->value_address ();
@@ -4396,7 +4396,7 @@ symbol_to_sal (struct symtab_and_line *result,
        {
          /* We know its line number.  */
          *result = {};
-         result->symtab = symbol_symtab (sym);
+         result->symtab = sym->symtab ();
          result->symbol = sym;
          result->line = sym->line ();
          result->pc = sym->value_address ();

diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c
index 6dcac13d2c5b69e56a0089f341a01719b43f6633..7083beb01ed352a2400eacefaef8ecf614e1b65e 100644 (file)
--- a/gdb/mdebugread.c
+++ b/gdb/mdebugread.c
@@ -4486,7 +4486,7 @@ mylookup_symbol (const char *name, const struct block *block,
 static void
 add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
 {
-  symbol_set_symtab (s, symtab);
+  s->set_symtab (symtab);
   mdict_add_symbol (BLOCK_MULTIDICT (b), s);
 }
 

diff --git a/gdb/mi/mi-symbol-cmds.c b/gdb/mi/mi-symbol-cmds.c
index 60321f767962b341790a324434b73ca48b7e7dea..56e9c3f3ce09893620cbf5fb02a2c4ec02a52e7e 100644 (file)
--- a/gdb/mi/mi-symbol-cmds.c
+++ b/gdb/mi/mi-symbol-cmds.c
@@ -132,7 +132,7 @@ mi_symbol_info (enum search_domain kind, const char *name_regexp,
       /* As long as we have debug symbols...  */
       while (i < symbols.size () && symbols[i].msymbol.minsym == nullptr)
        {
-         symtab *symtab = symbol_symtab (symbols[i].symbol);
+         symtab *symtab = symbols[i].symbol->symtab ();
          ui_out_emit_tuple symtab_tuple_emitter (uiout, nullptr);
 
          uiout->field_string ("filename",
@@ -144,7 +144,7 @@ mi_symbol_info (enum search_domain kind, const char *name_regexp,
          /* As long as we have debug symbols from this symtab...  */
          for (; (i < symbols.size ()
                  && symbols[i].msymbol.minsym == nullptr
-                 && symbol_symtab (symbols[i].symbol) == symtab);
+                 && symbols[i].symbol->symtab () == symtab);
               ++i)
            {
              symbol_search &s = symbols[i];
@@ -256,7 +256,7 @@ output_module_symbols_in_single_module_and_file
 
   /* The symbol for the first result, and the symtab in which it resides.  */
   const symbol *first_result_symbol = iter->second.symbol;
-  symtab *first_symbtab = symbol_symtab (first_result_symbol);
+  symtab *first_symbtab = first_result_symbol->symtab ();
 
   /* Formatted output.  */
   ui_out_emit_tuple current_file (uiout, nullptr);
@@ -269,7 +269,7 @@ output_module_symbols_in_single_module_and_file
      we change module, or we change symtab.  */
   for (; (iter != end
          && first_module_symbol == iter->first.symbol
-         && first_symbtab == symbol_symtab (iter->second.symbol));
+         && first_symbtab == iter->second.symbol->symtab ());
        ++iter)
     output_debug_symbol (uiout, kind, iter->second.symbol,
                         iter->second.block);

diff --git a/gdb/python/py-symbol.c b/gdb/python/py-symbol.c
index 5d475504fe6cb7251373557458a56886079eac3d..414a310da64af1497f445cc851130a6028111b45 100644 (file)
--- a/gdb/python/py-symbol.c
+++ b/gdb/python/py-symbol.c
@@ -91,7 +91,7 @@ sympy_get_symtab (PyObject *self, void *closure)
   if (!symbol->is_objfile_owned ())
     Py_RETURN_NONE;
 
-  return symtab_to_symtab_object (symbol_symtab (symbol));
+  return symtab_to_symtab_object (symbol->symtab ());
 }
 
 static PyObject *
@@ -303,7 +303,7 @@ set_symbol (symbol_object *obj, struct symbol *symbol)
   obj->symbol = symbol;
   obj->prev = NULL;
   if (symbol->is_objfile_owned ()
-      && symbol_symtab (symbol) != NULL)
+      && symbol->symtab () != NULL)
     {
       struct objfile *objfile = symbol->objfile ();
 
@@ -349,7 +349,7 @@ sympy_dealloc (PyObject *obj)
     sym_obj->prev->next = sym_obj->next;
   else if (sym_obj->symbol != NULL
           && sym_obj->symbol->is_objfile_owned ()
-          && symbol_symtab (sym_obj->symbol) != NULL)
+          && sym_obj->symbol->symtab () != NULL)
     {
       set_objfile_data (sym_obj->symbol->objfile (),
                        sympy_objfile_data_key, sym_obj->next);

diff --git a/gdb/python/python.c b/gdb/python/python.c
index 7a9c8c1b66e389462c43abf22bc5ab6e830c3361..11aaa7ae778d5fb7ec6ffe4f9412231433d93b9e 100644 (file)
--- a/gdb/python/python.c
+++ b/gdb/python/python.c
@@ -831,7 +831,7 @@ gdbpy_rbreak (PyObject *self, PyObject *args, PyObject *kw)
 
       if (p.msymbol.minsym == NULL)
        {
-         struct symtab *symtab = symbol_symtab (p.symbol);
+         struct symtab *symtab = p.symbol->symtab ();
          const char *fullname = symtab_to_fullname (symtab);
 
          symbol_name = fullname;

diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c
index 1d5f839385cdf32b993dd04e16aba7179897be9f..373d82b8b99f671aa27a2d6b3c5956b3add1a055 100644 (file)
--- a/gdb/record-btrace.c
+++ b/gdb/record-btrace.c
@@ -1067,7 +1067,7 @@ btrace_compute_src_line_range (const struct btrace_function *bfun,
   if (sym == NULL)
     goto out;
 
-  symtab = symbol_symtab (sym);
+  symtab = sym->symtab ();
 
   for (const btrace_insn &insn : bfun->insn)
     {
@@ -1100,7 +1100,7 @@ btrace_call_history_src_line (struct ui_out *uiout,
     return;
 
   uiout->field_string ("file",
-                      symtab_to_filename_for_display (symbol_symtab (sym)),
+                      symtab_to_filename_for_display (sym->symtab ()),
                       file_name_style.style ());
 
   btrace_compute_src_line_range (bfun, &begin, &end);

diff --git a/gdb/source.c b/gdb/source.c
index 9d9ff4bbc3e993247afca3f8a0bcf20e091e29d1..8691113c729019e1dc9894df7fd30fc9f09f7e17 100644 (file)
--- a/gdb/source.c
+++ b/gdb/source.c
@@ -329,7 +329,7 @@ select_source_symtab (struct symtab *s)
       if (sal.symtab == NULL)
        /* We couldn't find the location of `main', possibly due to missing
           line number info, fall back to line 1 in the corresponding file.  */
-       loc->set (symbol_symtab (bsym.symbol), 1);
+       loc->set (bsym.symbol->symtab (), 1);
       else
        loc->set (sal.symtab, std::max (sal.line - (lines_to_list - 1), 1));
       return;

diff --git a/gdb/symtab.c b/gdb/symtab.c
index d5d3877d90ea4f78d5f6b9c4b380e894d5907406..6926d1559b2076bdd5f24adb6aa8ca5f4a055695 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1803,7 +1803,7 @@ fixup_symbol_section (struct symbol *sym, struct objfile *objfile)
 
   /* We either have an OBJFILE, or we can get at it from the sym's
      symtab.  Anything else is a bug.  */
-  gdb_assert (objfile || symbol_symtab (sym));
+  gdb_assert (objfile || sym->symtab ());
 
   if (objfile == NULL)
     objfile = sym->objfile ();
@@ -3940,7 +3940,7 @@ skip_prologue_sal (struct symtab_and_line *sal)
      have proven the CU (Compilation Unit) supports it.  sal->SYMTAB does not
      have to be set by the caller so we use SYM instead.  */
   if (sym != NULL
-      && symbol_symtab (sym)->compunit ()->locations_valid ())
+      && sym->symtab ()->compunit ()->locations_valid ())
     force_skip = 0;
 
   saved_pc = pc;
@@ -4020,7 +4020,7 @@ skip_prologue_sal (struct symtab_and_line *sal)
      is aligned.  */
   if (!force_skip && sym && start_sal.symtab == NULL)
     {
-      pc = skip_prologue_using_lineinfo (pc, symbol_symtab (sym));
+      pc = skip_prologue_using_lineinfo (pc, sym->symtab ());
       /* Recalculate the line number.  */
       start_sal = find_pc_sect_line (pc, section, 0);
     }
@@ -4052,7 +4052,7 @@ skip_prologue_sal (struct symtab_and_line *sal)
       && BLOCK_FUNCTION (function_block)->line () != 0)
     {
       sal->line = BLOCK_FUNCTION (function_block)->line ();
-      sal->symtab = symbol_symtab (BLOCK_FUNCTION (function_block));
+      sal->symtab = BLOCK_FUNCTION (function_block)->symtab ();
     }
 }
 
@@ -4692,8 +4692,8 @@ symbol_search::compare_search_syms (const symbol_search &sym_a,
 {
   int c;
 
-  c = FILENAME_CMP (symbol_symtab (sym_a.symbol)->filename,
-                   symbol_symtab (sym_b.symbol)->filename);
+  c = FILENAME_CMP (sym_a.symbol->symtab ()->filename,
+                   sym_b.symbol->symtab ()->filename);
   if (c != 0)
     return c;
 
@@ -4873,7 +4873,7 @@ global_symbol_searcher::add_matching_symbols
 
          ALL_BLOCK_SYMBOLS (b, iter, sym)
            {
-             struct symtab *real_symtab = symbol_symtab (sym);
+             struct symtab *real_symtab = sym->symtab ();
 
              QUIT;
 
@@ -5146,7 +5146,7 @@ print_symbol_info (enum search_domain kind,
                   int block, const char *last)
 {
   scoped_switch_to_sym_language_if_auto l (sym);
-  struct symtab *s = symbol_symtab (sym);
+  struct symtab *s = sym->symtab ();
 
   if (last != NULL)
     {
@@ -5266,7 +5266,7 @@ symtab_symbol_info (bool quiet, bool exclude_minsyms,
                             p.block,
                             last_filename);
          last_filename
-           = symtab_to_filename_for_display (symbol_symtab (p.symbol));
+           = symtab_to_filename_for_display (p.symbol->symtab ());
        }
     }
 }
@@ -5486,7 +5486,7 @@ rbreak_command (const char *regexp, int from_tty)
     {
       if (p.msymbol.minsym == NULL)
        {
-         struct symtab *symtab = symbol_symtab (p.symbol);
+         struct symtab *symtab = p.symbol->symtab ();
          const char *fullname = symtab_to_fullname (symtab);
 
          string = string_printf ("%s:'%s'", fullname,
@@ -6612,19 +6612,19 @@ symbol::arch () const
 /* See symtab.h.  */
 
 struct symtab *
-symbol_symtab (const struct symbol *symbol)
+symbol::symtab () const
 {
-  gdb_assert (symbol->is_objfile_owned ());
-  return symbol->owner.symtab;
+  gdb_assert (is_objfile_owned ());
+  return owner.symtab;
 }
 
 /* See symtab.h.  */
 
 void
-symbol_set_symtab (struct symbol *symbol, struct symtab *symtab)
+symbol::set_symtab (struct symtab *symtab)
 {
-  gdb_assert (symbol->is_objfile_owned ());
-  symbol->owner.symtab = symtab;
+  gdb_assert (is_objfile_owned ());
+  owner.symtab = symtab;
 }
 
 /* See symtab.h.  */
@@ -6870,7 +6870,7 @@ info_module_subcommand (bool quiet, const char *module_regexp,
       print_symbol_info (FUNCTIONS_DOMAIN, q.symbol, q.block,
                         last_filename);
       last_filename
-       = symtab_to_filename_for_display (symbol_symtab (q.symbol));
+       = symtab_to_filename_for_display (q.symbol->symtab ());
     }
 }
 

diff --git a/gdb/symtab.h b/gdb/symtab.h
index a773fccf50fbe86b6344ef0cb649c23eef6d7dd3..40283350cbe887212194d9fe0cd7ece491a2f56a 100644 (file)
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -1386,6 +1386,18 @@ struct symbol : public general_symbol_info, public allocate_on_obstack
 
   struct gdbarch *arch () const;
 
+  /* Return the symtab of this symbol.  It is an error to call this if
+     is_objfile_owned is false, which only happens for
+     architecture-provided types.  */
+
+  struct symtab *symtab () const;
+
+  /* Set the symtab of this symbol to SYMTAB.  It is an error to call
+     this if is_objfile_owned is false, which only happens for
+     architecture-provided types.  */
+
+  void set_symtab (struct symtab *symtab);
+
   /* Data type of value */
 
   struct type *m_type = nullptr;
@@ -1502,18 +1514,6 @@ extern int register_symbol_block_impl (enum address_class aclass,
 extern int register_symbol_register_impl (enum address_class,
                                          const struct symbol_register_ops *);
 
-/* Return the SYMTAB of SYMBOL.
-   It is an error to call this if symbol.is_objfile_owned is false, which
-   only happens for architecture-provided types.  */
-
-extern struct symtab *symbol_symtab (const struct symbol *symbol);
-
-/* Set the symtab of SYMBOL to SYMTAB.
-   It is an error to call this if symbol.is_objfile_owned is false, which
-   only happens for architecture-provided types.  */
-
-extern void symbol_set_symtab (struct symbol *symbol, struct symtab *symtab);
-
 /* An instance of this type is used to represent a C++ template
    function.  A symbol is really of this type iff
    symbol::is_cplus_template_function is true.  */