From: Tom Tromey Date: Tue, 17 Jan 2023 00:39:55 +0000 (-0700) Subject: Convert more block functions to methods X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=3c45e9f915ae4aeab7312d6fc55a947859057572;p=binutils-gdb.git 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. --- 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 &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 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)