Introduce expression::evaluate

This introduces a new method, expression::evaluate, and changes the
top-level expression-evaluation functions to use it.  Stack temporary
handling is moved into this new method, which makes sense because that
handling was only done when "*pos == 0".

This patch avoids some temporary regressions related to stack
temporary in the larger expression rewrite series.  I've pulled it out
separately because it seems like a reasonable change in its own right,
and because it's better to avoid making that series even longer.

Regression tested on x86-64 Fedora 32.

gdb/ChangeLog
2021-02-18  Tom Tromey  <tom@tromey.com>

	* expression.h (struct expression) <evaluate>: Declare method.
	* eval.c (evaluate_subexp): Simplify.
	(expression::evaluate): New method.
	(evaluate_expression, evaluate_type): Use expression::evaluate.

3 files changed, 37 insertions, 22 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 030eb9f..0349d44 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,10 @@
+2021-02-18  Tom Tromey  <tom@tromey.com>
+
+	* expression.h (struct expression) <evaluate>: Declare method.
+	* eval.c (evaluate_subexp): Simplify.
+	(expression::evaluate): New method.
+	(evaluate_expression, evaluate_type): Use expression::evaluate.
+
 2021-02-17  Kevin Buettner  <kevinb@redhat.com>
 
 	* ada-lang.c (ada_fold_name): Check for non-empty string prior
diff --git a/gdb/eval.c b/gdb/eval.c
index e63511b..8256fde 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -61,22 +61,8 @@ struct value *
 evaluate_subexp (struct type *expect_type, struct expression *exp,
 		 int *pos, enum noside noside)
 {
-  struct value *retval;
-
-  gdb::optional<enable_thread_stack_temporaries> stack_temporaries;
-  if (*pos == 0 && target_has_execution ()
-      && exp->language_defn->la_language == language_cplus
-      && !thread_stack_temporaries_enabled_p (inferior_thread ()))
-    stack_temporaries.emplace (inferior_thread ());
-
-  retval = (*exp->language_defn->expression_ops ()->evaluate_exp)
-    (expect_type, exp, pos, noside);
-
-  if (stack_temporaries.has_value ()
-      && value_in_thread_stack_temporaries (retval, inferior_thread ()))
-    retval = value_non_lval (retval);
-
-  return retval;
+  return ((*exp->language_defn->expression_ops ()->evaluate_exp)
+	  (expect_type, exp, pos, noside));
 }
 
 /* Parse the string EXP as a C expression, evaluate it,
@@ -121,14 +107,33 @@ parse_to_comma_and_eval (const char **expp)
 }
 
 
+/* See expression.h.  */
+
+struct value *
+expression::evaluate (struct type *expect_type, enum noside noside)
+{
+  gdb::optional<enable_thread_stack_temporaries> stack_temporaries;
+  if (target_has_execution ()
+      && language_defn->la_language == language_cplus
+      && !thread_stack_temporaries_enabled_p (inferior_thread ()))
+    stack_temporaries.emplace (inferior_thread ());
+
+  int pos = 0;
+  struct value *retval = evaluate_subexp (expect_type, this, &pos, noside);
+
+  if (stack_temporaries.has_value ()
+      && value_in_thread_stack_temporaries (retval, inferior_thread ()))
+    retval = value_non_lval (retval);
+
+  return retval;
+}
+
 /* See value.h.  */
 
 struct value *
 evaluate_expression (struct expression *exp, struct type *expect_type)
 {
-  int pc = 0;
-
-  return evaluate_subexp (expect_type, exp, &pc, EVAL_NORMAL);
+  return exp->evaluate (expect_type, EVAL_NORMAL);
 }
 
 /* Evaluate an expression, avoiding all memory references
@@ -137,9 +142,7 @@ evaluate_expression (struct expression *exp, struct type *expect_type)
 struct value *
 evaluate_type (struct expression *exp)
 {
-  int pc = 0;
-
-  return evaluate_subexp (nullptr, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
+  return exp->evaluate (nullptr, EVAL_AVOID_SIDE_EFFECTS);
 }
 
 /* Evaluate a subexpression, avoiding all memory references and
diff --git a/gdb/expression.h b/gdb/expression.h
index e70169e..397a0af 100644
--- a/gdb/expression.h
+++ b/gdb/expression.h
@@ -120,6 +120,11 @@ struct expression
       return elts[0].opcode;
   }
 
+  /* Evaluate the expression.  EXPECT_TYPE is the context type of the
+     expression; normally this should be nullptr.  NOSIDE controls how
+     evaluation is performed.  */
+  struct value *evaluate (struct type *expect_type, enum noside noside);
+
   /* Language it was entered in.  */
   const struct language_defn *language_defn;
   /* Architecture it was parsed in.  */