From 3c45e9f915ae4aeab7312d6fc55a947859057572 Mon Sep 17 00:00:00 2001
From: Tom Tromey <tom@tromey.com>
Date: Mon, 16 Jan 2023 17:39:55 -0700
Subject: [PATCH] Convert more block functions to methods

This converts block_scope, block_set_scope, block_using, and
block_set_using to be methods.  These are all done at once to make it
easier to also convert block_initialize_namespace at the same time.
This was mostly written by script.
---
 gdb/ada-lang.c     |  2 +-
 gdb/block.c        | 63 +++++++++++++++++++---------------------------
 gdb/block.h        | 48 +++++++++++++++++++++--------------
 gdb/buildsym.c     |  9 +++----
 gdb/cp-namespace.c |  6 ++---
 gdb/cp-support.c   |  2 +-
 gdb/d-namespace.c  |  4 +--
 gdb/dbxread.c      |  4 +--
 gdb/dwarf2/read.c  |  4 +--
 gdb/rust-lang.c    |  2 +-
 gdb/rust-lang.h    |  2 +-
 gdb/rust-parse.c   |  2 +-
 gdb/symtab.c       |  2 +-
 13 files changed, 74 insertions(+), 76 deletions(-)

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index a1de8c43bf2..e063f58a1a2 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -5424,7 +5424,7 @@ ada_add_block_renamings (std::vector<struct block_symbol> &result,
   symbol_name_matcher_ftype *name_match
     = ada_get_symbol_name_matcher (lookup_name);
 
-  for (renaming = block_using (block);
+  for (renaming = block->get_using ();
        renaming != NULL;
        renaming = renaming->next)
     {
diff --git a/gdb/block.c b/gdb/block.c
index 574086aa4f6..fc523332a3d 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -285,40 +285,36 @@ block_for_pc (CORE_ADDR pc)
 /* Now come some functions designed to deal with C++ namespace issues.
    The accessors are safe to use even in the non-C++ case.  */
 
-/* This returns the namespace that BLOCK is enclosed in, or "" if it
-   isn't enclosed in a namespace at all.  This travels the chain of
-   superblocks looking for a scope, if necessary.  */
+/* See block.h.  */
 
 const char *
-block_scope (const struct block *block)
+block::scope () const
 {
-  for (; block != NULL; block = block->superblock ())
+  for (const block *block = this;
+       block != nullptr;
+       block = block->superblock ())
     {
-      if (block->namespace_info () != NULL
-	  && block->namespace_info ()->scope != NULL)
-	return block->namespace_info ()->scope;
+      if (block->m_namespace_info != nullptr
+	  && block->m_namespace_info->scope != nullptr)
+	return block->m_namespace_info->scope;
     }
 
   return "";
 }
 
-/* If block->namespace_info () is NULL, allocate it via OBSTACK and
-   initialize its members to zero.  */
+/* See block.h.  */
 
-static void
-block_initialize_namespace (struct block *block, struct obstack *obstack)
+void
+block::initialize_namespace (struct obstack *obstack)
 {
-  if (block->namespace_info () == NULL)
-    block->set_namespace_info (new (obstack) struct block_namespace_info ());
+  if (m_namespace_info == nullptr)
+    m_namespace_info = new (obstack) struct block_namespace_info;
 }
 
-/* Set BLOCK's scope member to SCOPE; if needed, allocate memory via
-   OBSTACK.  (It won't make a copy of SCOPE, however, so that already
-   has to be allocated correctly.)  */
+/* See block.h.  */
 
 void
-block_set_scope (struct block *block, const char *scope,
-		 struct obstack *obstack)
+block::set_scope (const char *scope, struct obstack *obstack)
 {
   if (scope == nullptr || scope[0] == '\0')
     {
@@ -326,31 +322,25 @@ block_set_scope (struct block *block, const char *scope,
       return;
     }
 
-  block_initialize_namespace (block, obstack);
-
-  block->namespace_info ()->scope = scope;
+  initialize_namespace (obstack);
+  m_namespace_info->scope = scope;
 }
 
-/* This returns the using directives list associated with BLOCK, if
-   any.  */
+/* See block.h.  */
 
 struct using_direct *
-block_using (const struct block *block)
+block::get_using () const
 {
-  if (block->namespace_info () == NULL)
-    return NULL;
+  if (m_namespace_info == nullptr)
+    return nullptr;
   else
-    return block->namespace_info ()->using_decl;
+    return m_namespace_info->using_decl;
 }
 
-/* Set BLOCK's using member to USING; if needed, allocate memory via
-   OBSTACK.  (It won't make a copy of USING, however, so that already
-   has to be allocated correctly.)  */
+/* See block.h.  */
 
 void
-block_set_using (struct block *block,
-		 struct using_direct *using_decl,
-		 struct obstack *obstack)
+block::set_using (struct using_direct *using_decl, struct obstack *obstack)
 {
   if (using_decl == nullptr)
     {
@@ -358,9 +348,8 @@ block_set_using (struct block *block,
       return;
     }
 
-  block_initialize_namespace (block, obstack);
-
-  block->namespace_info ()->using_decl = using_decl;
+  initialize_namespace (obstack);
+  m_namespace_info->using_decl = using_decl;
 }
 
 /* Return the static block associated to BLOCK.  Return NULL if block
diff --git a/gdb/block.h b/gdb/block.h
index ab343b44698..680b7d0161e 100644
--- a/gdb/block.h
+++ b/gdb/block.h
@@ -147,14 +147,6 @@ struct block
   void set_multidict (multidictionary *multidict)
   { m_multidict = multidict; }
 
-  /* Return this block's namespace info.  */
-  block_namespace_info *namespace_info () const
-  { return m_namespace_info; }
-
-  /* Set this block's namespace info.  */
-  void set_namespace_info (block_namespace_info *namespace_info)
-  { m_namespace_info = namespace_info; }
-
   /* Return a view on this block's ranges.  */
   gdb::array_view<blockrange> ranges ()
   {
@@ -216,6 +208,29 @@ struct block
 
   bool inlined_p () const;
 
+  /* This returns the namespace that this block is enclosed in, or ""
+     if it isn't enclosed in a namespace at all.  This travels the
+     chain of superblocks looking for a scope, if necessary.  */
+
+  const char *scope () const;
+
+  /* Set this block's scope member to SCOPE; if needed, allocate
+     memory via OBSTACK.  (It won't make a copy of SCOPE, however, so
+     that already has to be allocated correctly.)  */
+
+  void set_scope (const char *scope, struct obstack *obstack);
+
+  /* This returns the using directives list associated with this
+     block, if any.  */
+
+  struct using_direct *get_using () const;
+
+  /* Set this block's using member to USING; if needed, allocate
+     memory via OBSTACK.  (It won't make a copy of USING, however, so
+     that already has to be allocated correctly.)  */
+
+  void set_using (struct using_direct *using_decl, struct obstack *obstack);
+
   /* Addresses in the executable code that are in this block.  */
 
   CORE_ADDR m_start;
@@ -248,6 +263,12 @@ struct block
      startaddr and endaddr above.  */
 
   struct blockranges *m_ranges;
+
+private:
+
+  /* If the namespace_info is NULL, allocate it via OBSTACK and
+     initialize its members to zero.  */
+  void initialize_namespace (struct obstack *obstack);
 };
 
 /* The global block is singled out so that we can provide a back-link
@@ -373,17 +394,6 @@ extern const struct block *block_for_pc (CORE_ADDR);
 
 extern const struct block *block_for_pc_sect (CORE_ADDR, struct obj_section *);
 
-extern const char *block_scope (const struct block *block);
-
-extern void block_set_scope (struct block *block, const char *scope,
-			     struct obstack *obstack);
-
-extern struct using_direct *block_using (const struct block *block);
-
-extern void block_set_using (struct block *block,
-			     struct using_direct *using_decl,
-			     struct obstack *obstack);
-
 extern const struct block *block_static_block (const struct block *block);
 
 extern const struct block *block_global_block (const struct block *block);
diff --git a/gdb/buildsym.c b/gdb/buildsym.c
index 8dbb327f0eb..adc554e587a 100644
--- a/gdb/buildsym.c
+++ b/gdb/buildsym.c
@@ -372,11 +372,10 @@ buildsym_compunit::finish_block_internal
       opblock = pblock;
     }
 
-  block_set_using (block,
-		   (is_global
-		    ? m_global_using_directives
-		    : m_local_using_directives),
-		   &m_objfile->objfile_obstack);
+  block->set_using ((is_global
+		     ? m_global_using_directives
+		     : m_local_using_directives),
+		    &m_objfile->objfile_obstack);
   if (is_global)
     m_global_using_directives = NULL;
   else
diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index 97b7a653e33..2d44b7bc047 100644
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -413,7 +413,7 @@ cp_lookup_symbol_via_imports (const char *scope,
   /* Go through the using directives.  If any of them add new names to
      the namespace we're searching in, see if we can find a match by
      applying them.  */
-  for (current = block_using (block);
+  for (current = block->get_using ();
        current != NULL;
        current = current->next)
     {
@@ -769,7 +769,7 @@ cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
 			   const domain_enum domain)
 {
   struct block_symbol sym;
-  const char *scope = block_scope (block);
+  const char *scope = block == nullptr ? "" : block->scope ();
 
   symbol_lookup_debug_printf
     ("cp_lookup_symbol_non_local (%s, %s (scope %s), %s)",
@@ -1025,7 +1025,7 @@ cp_lookup_transparent_type (const char *name)
 
   /* If that doesn't work and we're within a namespace, look there
      instead.  */
-  scope = block_scope (get_selected_block (0));
+  scope = get_selected_block (0)->scope ();
 
   if (scope[0] == '\0')
     return NULL;
diff --git a/gdb/cp-support.c b/gdb/cp-support.c
index 764e2b8b469..fd5a286b779 100644
--- a/gdb/cp-support.c
+++ b/gdb/cp-support.c
@@ -1403,7 +1403,7 @@ add_symbol_overload_list_using (const char *func_name,
   for (block = get_selected_block (0);
        block != NULL;
        block = block->superblock ())
-    for (current = block_using (block);
+    for (current = block->get_using ();
 	current != NULL;
 	current = current->next)
       {
diff --git a/gdb/d-namespace.c b/gdb/d-namespace.c
index aaef1dfae1f..6153e5b3239 100644
--- a/gdb/d-namespace.c
+++ b/gdb/d-namespace.c
@@ -375,7 +375,7 @@ d_lookup_symbol_imports (const char *scope, const char *name,
      the module we're searching in, see if we can find a match by
      applying them.  */
 
-  for (current = block_using (block);
+  for (current = block->get_using ();
        current != NULL;
        current = current->next)
     {
@@ -511,7 +511,7 @@ d_lookup_symbol_nonlocal (const struct language_defn *langdef,
 			  const domain_enum domain)
 {
   struct block_symbol sym;
-  const char *scope = block == nullptr ? "" : block_scope (block);
+  const char *scope = block == nullptr ? "" : block->scope ();
 
   sym = lookup_module_scope (langdef, name, block, domain, scope, 0);
   if (sym.symbol != NULL)
diff --git a/gdb/dbxread.c b/gdb/dbxread.c
index 36e744fa61f..02c7e3118ad 100644
--- a/gdb/dbxread.c
+++ b/gdb/dbxread.c
@@ -2361,8 +2361,8 @@ cp_set_block_scope (const struct symbol *symbol,
       const char *name = symbol->demangled_name ();
       unsigned int prefix_len = cp_entire_prefix_len (name);
 
-      block_set_scope (block, obstack_strndup (obstack, name, prefix_len),
-		       obstack);
+      block->set_scope (obstack_strndup (obstack, name, prefix_len),
+			obstack);
     }
 }
 
diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 9ad1afa5d61..11a2d3e7c9a 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -10170,8 +10170,8 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
        || cu->lang () == language_d
        || cu->lang () == language_rust)
       && cu->processing_has_namespace_info)
-    block_set_scope (block, determine_prefix (die, cu),
-		     &objfile->objfile_obstack);
+    block->set_scope (determine_prefix (die, cu),
+		      &objfile->objfile_obstack);
 
   /* If we have address ranges, record them.  */
   dwarf2_record_block_ranges (die, block, baseaddr, cu);
diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index fb9db9fe31b..fe260f175f8 100644
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -58,7 +58,7 @@ rust_last_path_segment (const char *path)
 std::string
 rust_crate_for_block (const struct block *block)
 {
-  const char *scope = block_scope (block);
+  const char *scope = block->scope ();
 
   if (scope[0] == '\0')
     return std::string ();
diff --git a/gdb/rust-lang.h b/gdb/rust-lang.h
index 497342d4ef3..37a22e7a404 100644
--- a/gdb/rust-lang.h
+++ b/gdb/rust-lang.h
@@ -148,7 +148,7 @@ public:
   {
     struct block_symbol result = {};
 
-    const char *scope = block == nullptr ? "" : block_scope (block);
+    const char *scope = block == nullptr ? "" : block->scope ();
     symbol_lookup_debug_printf
       ("rust_lookup_symbol_non_local (%s, %s (scope %s), %s)",
        name, host_address_to_string (block), scope,
diff --git a/gdb/rust-parse.c b/gdb/rust-parse.c
index 72b843ef40c..9074d651d85 100644
--- a/gdb/rust-parse.c
+++ b/gdb/rust-parse.c
@@ -375,7 +375,7 @@ rust_parser::super_name (const std::string &ident, unsigned int n_supers)
 {
   const char *scope = "";
   if (pstate->expression_context_block != nullptr)
-    scope = block_scope (pstate->expression_context_block);
+    scope = pstate->expression_context_block->scope ();
   int offset;
 
   if (scope[0] == '\0')
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 52043e4de06..bd6abbf7319 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -2160,7 +2160,7 @@ lookup_local_symbol (const char *name,
 
   struct symbol *sym;
   const struct block *static_block = block_static_block (block);
-  const char *scope = block_scope (block);
+  const char *scope = block->scope ();
   
   /* Check if it's a global block.  */
   if (static_block == nullptr)
-- 
2.30.2