diff mbox series

Move lookup_name_info creation into basic_lookup_transparent_type

Message ID 20240125181929.5811-1-tromey@adacore.com
State New
Headers
Series Move lookup_name_info creation into basic_lookup_transparent_type |

Checks

Context Check Description
linaro-tcwg-bot/tcwg_gdb_build--master-aarch64 success Testing passed
linaro-tcwg-bot/tcwg_gdb_build--master-arm success Testing passed
linaro-tcwg-bot/tcwg_gdb_check--master-arm success Testing passed
linaro-tcwg-bot/tcwg_gdb_check--master-aarch64 success Testing passed

Commit Message

Tom Tromey Jan. 25, 2024, 6:19 p.m. UTC 
  I noticed that basic_lookup_transparent_type calls two different
functions that both proceed to create a lookup_name_info.  It's more
efficient to create this object in the outermost layer possible.
Making this change required a few related changes, resulting in this
patch.

There are still more changs of this sort that could be made.

Regression tested on x86-64 Fedora 38.
---
 gdb/block.c                       |  9 +++----
 gdb/block.h                       |  3 +--
 gdb/compile/compile-object-load.c | 13 +++++-----
 gdb/objfiles.h                    |  3 ++-
 gdb/psymtab.c                     | 12 ++++-----
 gdb/symfile-debug.c               | 11 ++++----
 gdb/symtab.c                      | 42 ++++++++++++++++++-------------
 7 files changed, 47 insertions(+), 46 deletions(-)

Comments

Tom Tromey Feb. 15, 2024, 5:11 p.m. UTC | #1 
>>>>> "Tom" == Tom Tromey <tromey@adacore.com> writes:

Tom> I noticed that basic_lookup_transparent_type calls two different
Tom> functions that both proceed to create a lookup_name_info.  It's more
Tom> efficient to create this object in the outermost layer possible.
Tom> Making this change required a few related changes, resulting in this
Tom> patch.

Tom> There are still more changs of this sort that could be made.

Tom> Regression tested on x86-64 Fedora 38.

I'm checking this in.

Tom
diff mbox series

Patch

diff --git a/gdb/block.c b/gdb/block.c
index 4b9307ea794..1dd3fd7adbf 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -673,17 +673,14 @@  better_symbol (struct symbol *a, struct symbol *b, const domain_enum domain)
    non-encoded names tested for a match.  */
 
 struct symbol *
-block_lookup_symbol (const struct block *block, const char *name,
-		     symbol_name_match_type match_type,
+block_lookup_symbol (const struct block *block, const lookup_name_info &name,
 		     const domain_enum domain)
 {
-  lookup_name_info lookup_name (name, match_type);
-
   if (!block->function ())
     {
       struct symbol *other = NULL;
 
-      for (struct symbol *sym : block_iterator_range (block, &lookup_name))
+      for (struct symbol *sym : block_iterator_range (block, &name))
 	{
 	  /* See comment related to PR gcc/debug/91507 in
 	     block_lookup_symbol_primary.  */
@@ -711,7 +708,7 @@  block_lookup_symbol (const struct block *block, const char *name,
 
       struct symbol *sym_found = NULL;
 
-      for (struct symbol *sym : block_iterator_range (block, &lookup_name))
+      for (struct symbol *sym : block_iterator_range (block, &name))
 	{
 	  if (sym->matches (domain))
 	    {
diff --git a/gdb/block.h b/gdb/block.h
index 5c56518bfce..2c07a19364b 100644
--- a/gdb/block.h
+++ b/gdb/block.h
@@ -565,8 +565,7 @@  extern struct symbol *better_symbol (struct symbol *a, struct symbol *b,
 /* Search BLOCK for symbol NAME in DOMAIN.  */
 
 extern struct symbol *block_lookup_symbol (const struct block *block,
-					   const char *name,
-					   symbol_name_match_type match_type,
+					   const lookup_name_info &name,
 					   const domain_enum domain);
 
 /* Search BLOCK for symbol NAME in DOMAIN but only in primary symbol table of
diff --git a/gdb/compile/compile-object-load.c b/gdb/compile/compile-object-load.c
index b2cc3a1a042..213070c80b3 100644
--- a/gdb/compile/compile-object-load.c
+++ b/gdb/compile/compile-object-load.c
@@ -421,6 +421,10 @@  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);
+  lookup_name_info i_val_matcher (COMPILE_I_EXPR_VAL,
+				  symbol_name_match_type::SEARCH_NAME);
+  lookup_name_info i_ptr_matcher (COMPILE_I_EXPR_PTR_TYPE,
+				  symbol_name_match_type::SEARCH_NAME);
 
   bv = func_sym->symtab ()->compunit ()->blockvector ();
   nblocks = bv->num_blocks ();
@@ -434,10 +438,7 @@  get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
       block = bv->block (block_loop);
       if (block->function () != NULL)
 	continue;
-      gdb_val_sym = block_lookup_symbol (block,
-					 COMPILE_I_EXPR_VAL,
-					 symbol_name_match_type::SEARCH_NAME,
-					 VAR_DOMAIN);
+      gdb_val_sym = block_lookup_symbol (block, i_val_matcher, VAR_DOMAIN);
       if (gdb_val_sym == NULL)
 	continue;
 
@@ -461,9 +462,7 @@  get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
   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,
-					  symbol_name_match_type::SEARCH_NAME,
-					  VAR_DOMAIN);
+  gdb_ptr_type_sym = block_lookup_symbol (block, i_ptr_matcher, VAR_DOMAIN);
   if (gdb_ptr_type_sym == NULL)
     error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
   gdb_ptr_type = gdb_ptr_type_sym->type ();
diff --git a/gdb/objfiles.h b/gdb/objfiles.h
index 65115ce17f0..0d9993db0b7 100644
--- a/gdb/objfiles.h
+++ b/gdb/objfiles.h
@@ -561,7 +561,8 @@  struct objfile
      defined, or NULL if no such symbol table exists.  If OBJFILE
      contains !TYPE_OPAQUE symbol prefer its compunit.  If it contains
      only TYPE_OPAQUE symbol(s), return at least that compunit.  */
-  struct compunit_symtab *lookup_symbol (block_enum kind, const char *name,
+  struct compunit_symtab *lookup_symbol (block_enum kind,
+					 const lookup_name_info &name,
 					 domain_enum domain);
 
   /* See quick_symbol_functions.  */
diff --git a/gdb/psymtab.c b/gdb/psymtab.c
index 4a3a872309d..7388618f41b 100644
--- a/gdb/psymtab.c
+++ b/gdb/psymtab.c
@@ -1522,9 +1522,9 @@  maintenance_check_psymtabs (const char *ignore, int from_tty)
 		      && psym->ginfo.value_address () == 0)
 		    continue;
 
-		  sym = block_lookup_symbol (b, psym->ginfo.search_name (),
-					     symbol_name_match_type::SEARCH_NAME,
-					     psym->domain);
+		  lookup_name_info lookup_name
+		    (psym->ginfo.search_name (), symbol_name_match_type::SEARCH_NAME);
+		  sym = block_lookup_symbol (b, lookup_name, psym->domain);
 		  if (!sym)
 		    {
 		      gdb_printf ("Static symbol `");
@@ -1537,9 +1537,9 @@  maintenance_check_psymtabs (const char *ignore, int from_tty)
 	      b = bv->global_block ();
 	      for (partial_symbol *psym : ps->global_psymbols)
 		{
-		  sym = block_lookup_symbol (b, psym->ginfo.search_name (),
-					     symbol_name_match_type::SEARCH_NAME,
-					     psym->domain);
+		  lookup_name_info lookup_name
+		    (psym->ginfo.search_name (), symbol_name_match_type::SEARCH_NAME);
+		  sym = block_lookup_symbol (b, lookup_name, psym->domain);
 		  if (!sym)
 		    {
 		      gdb_printf ("Global symbol `");
diff --git a/gdb/symfile-debug.c b/gdb/symfile-debug.c
index b0d2e19295d..2f8d761476f 100644
--- a/gdb/symfile-debug.c
+++ b/gdb/symfile-debug.c
@@ -241,25 +241,24 @@  objfile::map_symtabs_matching_filename
 }
 
 struct compunit_symtab *
-objfile::lookup_symbol (block_enum kind, const char *name, domain_enum domain)
+objfile::lookup_symbol (block_enum kind, const lookup_name_info &name,
+			domain_enum domain)
 {
   struct compunit_symtab *retval = nullptr;
 
   if (debug_symfile)
     gdb_printf (gdb_stdlog,
 		"qf->lookup_symbol (%s, %d, \"%s\", %s)\n",
-		objfile_debug_name (this), kind, name,
+		objfile_debug_name (this), kind, name.c_str (),
 		domain_name (domain));
 
-  lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
-
   auto search_one_symtab = [&] (compunit_symtab *stab)
   {
     struct symbol *sym, *with_opaque = NULL;
     const struct blockvector *bv = stab->blockvector ();
     const struct block *block = bv->block (kind);
 
-    sym = block_find_symbol (block, lookup_name, domain, &with_opaque);
+    sym = block_find_symbol (block, name, domain, &with_opaque);
 
     /* Some caution must be observed with overloaded functions
        and methods, since the index will not contain any overload
@@ -282,7 +281,7 @@  objfile::lookup_symbol (block_enum kind, const char *name, domain_enum domain)
     {
       if (!iter->expand_symtabs_matching (this,
 					  nullptr,
-					  &lookup_name,
+					  &name,
 					  nullptr,
 					  search_one_symtab,
 					  kind == GLOBAL_BLOCK
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 7c0a69108d4..3435029664d 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1994,13 +1994,14 @@  lookup_language_this (const struct language_defn *lang,
 				lang->name (), host_address_to_string (block),
 				objfile_debug_name (block->objfile ()));
 
+  lookup_name_info this_name (lang->name_of_this (),
+			      symbol_name_match_type::SEARCH_NAME);
+
   while (block)
     {
       struct symbol *sym;
 
-      sym = block_lookup_symbol (block, lang->name_of_this (),
-				 symbol_name_match_type::SEARCH_NAME,
-				 VAR_DOMAIN);
+      sym = block_lookup_symbol (block, this_name, VAR_DOMAIN);
       if (sym != NULL)
 	{
 	  symbol_lookup_debug_printf_v
@@ -2235,7 +2236,8 @@  lookup_symbol_in_block (const char *name, symbol_name_match_type match_type,
 	 domain_name (domain));
     }
 
-  sym = block_lookup_symbol (block, name, match_type, domain);
+  lookup_name_info lookup_name (name, match_type);
+  sym = block_lookup_symbol (block, lookup_name, domain);
   if (sym)
     {
       symbol_lookup_debug_printf_v ("lookup_symbol_in_block (...) = %s",
@@ -2409,7 +2411,8 @@  lookup_symbol_via_quick_fns (struct objfile *objfile,
      block_index == GLOBAL_BLOCK ? "GLOBAL_BLOCK" : "STATIC_BLOCK",
      name, domain_name (domain));
 
-  cust = objfile->lookup_symbol (block_index, name, domain);
+  lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
+  cust = objfile->lookup_symbol (block_index, lookup_name, domain);
   if (cust == NULL)
     {
       symbol_lookup_debug_printf_v
@@ -2419,8 +2422,7 @@  lookup_symbol_via_quick_fns (struct objfile *objfile,
 
   bv = cust->blockvector ();
   block = bv->block (block_index);
-  result.symbol = block_lookup_symbol (block, name,
-				       symbol_name_match_type::FULL, domain);
+  result.symbol = block_lookup_symbol (block, lookup_name, domain);
   if (result.symbol == NULL)
     error_in_psymtab_expansion (block_index, name, cust);
 
@@ -2680,7 +2682,7 @@  lookup_transparent_type (const char *name)
 static struct type *
 basic_lookup_transparent_type_quick (struct objfile *objfile,
 				     enum block_enum block_index,
-				     const char *name)
+				     const lookup_name_info &name)
 {
   struct compunit_symtab *cust;
   const struct blockvector *bv;
@@ -2694,10 +2696,9 @@  basic_lookup_transparent_type_quick (struct objfile *objfile,
   bv = cust->blockvector ();
   block = bv->block (block_index);
 
-  lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
-  sym = block_find_symbol (block, lookup_name, STRUCT_DOMAIN, nullptr);
+  sym = block_find_symbol (block, name, STRUCT_DOMAIN, nullptr);
   if (sym == nullptr)
-    error_in_psymtab_expansion (block_index, name, cust);
+    error_in_psymtab_expansion (block_index, name.c_str (), cust);
   gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
   return sym->type ();
 }
@@ -2709,18 +2710,17 @@  basic_lookup_transparent_type_quick (struct objfile *objfile,
 static struct type *
 basic_lookup_transparent_type_1 (struct objfile *objfile,
 				 enum block_enum block_index,
-				 const char *name)
+				 const lookup_name_info &name)
 {
   const struct blockvector *bv;
   const struct block *block;
   const struct symbol *sym;
 
-  lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
   for (compunit_symtab *cust : objfile->compunits ())
     {
       bv = cust->blockvector ();
       block = bv->block (block_index);
-      sym = block_find_symbol (block, lookup_name, STRUCT_DOMAIN, nullptr);
+      sym = block_find_symbol (block, name, STRUCT_DOMAIN, nullptr);
       if (sym != nullptr)
 	{
 	  gdb_assert (!TYPE_IS_OPAQUE (sym->type ()));
@@ -2742,6 +2742,8 @@  basic_lookup_transparent_type (const char *name)
 {
   struct type *t;
 
+  lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
+
   /* Now search all the global symbols.  Do the symtab's first, then
      check the psymtab's.  If a psymtab indicates the existence
      of the desired name as a global, then do psymtab-to-symtab
@@ -2749,14 +2751,16 @@  basic_lookup_transparent_type (const char *name)
 
   for (objfile *objfile : current_program_space->objfiles ())
     {
-      t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK, name);
+      t = basic_lookup_transparent_type_1 (objfile, GLOBAL_BLOCK,
+					   lookup_name);
       if (t)
 	return t;
     }
 
   for (objfile *objfile : current_program_space->objfiles ())
     {
-      t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK, name);
+      t = basic_lookup_transparent_type_quick (objfile, GLOBAL_BLOCK,
+					       lookup_name);
       if (t)
 	return t;
     }
@@ -2770,14 +2774,16 @@  basic_lookup_transparent_type (const char *name)
 
   for (objfile *objfile : current_program_space->objfiles ())
     {
-      t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK, name);
+      t = basic_lookup_transparent_type_1 (objfile, STATIC_BLOCK,
+					   lookup_name);
       if (t)
 	return t;
     }
 
   for (objfile *objfile : current_program_space->objfiles ())
     {
-      t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK, name);
+      t = basic_lookup_transparent_type_quick (objfile, STATIC_BLOCK,
+					       lookup_name);
       if (t)
 	return t;
     }