[PATCH v2 31/31] Change language_defn::read_var_value to accept block_symbol

[Tom Tromey <tom@tromey.com>]

This changes language_defn::read_var_value to accept a block_symbol,
and to call block_symbol::address.
---
 gdb/ada-lang.c |  9 ++++-----
 gdb/findvar.c  | 17 ++++++++---------
 gdb/language.h | 14 ++++----------
 3 files changed, 16 insertions(+), 24 deletions(-)

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 6beadad568a..ad39f5d496c 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -13391,8 +13391,7 @@ class ada_language : public language_defn
 
   /* Implement the "read_var_value" language_defn method for Ada.  */
 
-  struct value *read_var_value (struct symbol *var,
-				const struct block *var_block,
+  struct value *read_var_value (block_symbol var,
 				frame_info_ptr frame) const override
   {
     /* The only case where default_read_var_value is not sufficient
@@ -13400,13 +13399,13 @@ class ada_language : public language_defn
     if (frame != nullptr)
       {
 	const struct block *frame_block = get_frame_block (frame, NULL);
-	if (frame_block != nullptr && ada_is_renaming_symbol (var))
-	  return ada_read_renaming_var_value (var, frame_block);
+	if (frame_block != nullptr && ada_is_renaming_symbol (var.symbol))
+	  return ada_read_renaming_var_value (var.symbol, frame_block);
       }
 
     /* This is a typical case where we expect the default_read_var_value
        function to work.  */
-    return language_defn::read_var_value (var, var_block, frame);
+    return language_defn::read_var_value (var, frame);
   }
 
   /* See language.h.  */
diff --git a/gdb/findvar.c b/gdb/findvar.c
index 4282d85425a..359024e931b 100644
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -549,11 +549,10 @@ get_hosting_frame (struct symbol *var, const struct block *var_block,
 /* See language.h.  */
 
 struct value *
-language_defn::read_var_value (struct symbol *var,
-			       const struct block *var_block,
-			       frame_info_ptr frame) const
+language_defn::read_var_value (block_symbol bvar, frame_info_ptr frame) const
 {
   struct value *v;
+  symbol *var = bvar.symbol;
   struct type *type = var->type ();
   CORE_ADDR addr;
   enum symbol_needs_kind sym_need;
@@ -572,7 +571,7 @@ language_defn::read_var_value (struct symbol *var,
     error (_("Cannot read `%s' without registers"), var->print_name ());
 
   if (frame != NULL)
-    frame = get_hosting_frame (var, var_block, frame);
+    frame = get_hosting_frame (var, bvar.block, frame);
 
   if (SYMBOL_COMPUTED_OPS (var) != NULL)
     return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
@@ -598,11 +597,11 @@ language_defn::read_var_value (struct symbol *var,
 	if (overlay_debugging)
 	  {
 	    struct objfile *var_objfile = var->objfile ();
-	    addr = symbol_overlayed_address (var->value_address (),
+	    addr = symbol_overlayed_address (bvar.address (),
 					     var->obj_section (var_objfile));
 	  }
 	else
-	  addr = var->value_address ();
+	  addr = bvar.address ();
 
 	/* First convert the CORE_ADDR to a function pointer type, this
 	   ensures the gdbarch knows what type of pointer we are
@@ -635,10 +634,10 @@ language_defn::read_var_value (struct symbol *var,
     case LOC_STATIC:
       if (overlay_debugging)
 	addr
-	  = symbol_overlayed_address (var->value_address (),
+	  = symbol_overlayed_address (bvar.address (),
 				      var->obj_section (var->objfile ()));
       else
-	addr = var->value_address ();
+	addr = bvar.address ();
       break;
 
     case LOC_ARG:
@@ -790,7 +789,7 @@ read_var_value (block_symbol var, frame_info_ptr frame)
 
   gdb_assert (lang != NULL);
 
-  return lang->read_var_value (var.symbol, var.block, frame);
+  return lang->read_var_value (var, frame);
 }
 
 /* Install default attributes for register values.  */
diff --git a/gdb/language.h b/gdb/language.h
index 6ee8f6160e1..ede720ef7c8 100644
--- a/gdb/language.h
+++ b/gdb/language.h
@@ -308,19 +308,13 @@ struct language_defn
 				  struct ui_file *stream,
 				  const value_print_options *options) const;
 
-  /* Given a symbol VAR, the corresponding block VAR_BLOCK (if any) and a
-     stack frame id FRAME, read the value of the variable and return (pointer
-     to a) struct value containing the value.
-
-     VAR_BLOCK is needed if there's a possibility for VAR to be outside
-     FRAME.  This is what happens if FRAME correspond to a nested function
-     and VAR is defined in the outer function.  If callers know that VAR is
-     located in FRAME or is global/static, NULL can be passed as VAR_BLOCK.
+  /* Given a block_symbol VAR and a stack frame id FRAME, read the
+     value of the variable and return (pointer to a) struct value
+     containing the value.
 
      Throw an error if the variable cannot be found.  */
 
-  virtual struct value *read_var_value (struct symbol *var,
-					const struct block *var_block,
+  virtual struct value *read_var_value (block_symbol var,
 					frame_info_ptr frame) const;
 
   /* Return information about whether TYPE should be passed

-- 
2.41.0