[PATCH 142/203] Implement function call operations

Tom Tromey
2021-01-01T21:49:12Z

This implement function call operations.

The current function call code relies on some very lengthy code
(evaluate_funcall is 398 lines...) to distinguish between the
different opcodes that might appear in the callee position.

Rather than try to replicate this, and have a function that tried to
dissect many different kinds of operation subclass, this patch instead
puts the work into the callee. A new operation::evaluate_funcall
method is added, and then this is overridden in the classes that
require special treatment.

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

* expression.h (class operation) <evaluate_funcall>: New method.
* expop.h (class scope_operation) <evaluate_funcall>: New method.
(class var_value_operation) <evaluate_funcall>: New method.
(class structop_base_operation) <evaluate_funcall>: New method.
(class structop_member_base): New class.
(class structop_member_operation): Derive from
structop_member_base.
(class structop_mptr_operation): Derive from
structop_member_base.
(class funcall_operation): New class.
* eval.c (operation::evaluate_funcall)
(var_value_operation::evaluate_funcall)
(scope_operation::evaluate_funcall)
(structop_member_base::evaluate_funcall)
(structop_base_operation::evaluate_funcall): New methods.
---
gdb/ChangeLog | 18 +++
gdb/eval.c | 279 +++++++++++++++++++++++++++++++++++++++++++++++
gdb/expop.h | 55 +++++++++-
gdb/expression.h | 9 ++
4 files changed, 358 insertions(+), 3 deletions(-)

diff --git a/gdb/eval.c b/gdb/eval.c
index 2589e35ae30..ff3c58cd4a8 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -1202,6 +1202,285 @@ evaluate_funcall (type *expect_type, expression *exp, int *pos,
var_func_name, expect_type);
}

+namespace expr
+{
+
+value *
+operation::evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &args)
+{
+ std::vector<value *> vals (args.size ());
+
+ value *callee = evaluate_with_coercion (exp, noside);
+ for (int i = 0; i < args.size (); ++i)
+ vals[i] = args[i]->evaluate_with_coercion (exp, noside);
+
+ return evaluate_subexp_do_call (exp, noside, callee, vals,
+ nullptr, expect_type);
+}
+
+value *
+var_value_operation::evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &args)
+{
+ if (!overload_resolution
+ || exp->language_defn->la_language != language_cplus)
+ return operation::evaluate_funcall (expect_type, exp, noside, args);
+
+ std::vector<value *> argvec (args.size ());
+ for (int i = 0; i < args.size (); ++i)
+ argvec[i] = args[i]->evaluate_with_coercion (exp, noside);
+
+ struct symbol *symp;
+ find_overload_match (argvec, NULL, NON_METHOD,
+ NULL, std::get<0> (m_storage),
+ NULL, &symp, NULL, 0, noside);
+
+ if (SYMBOL_TYPE (symp)->code () == TYPE_CODE_ERROR)
+ error_unknown_type (symp->print_name ());
+ value *callee = evaluate_var_value (noside, std::get<1> (m_storage), symp);
+
+ return evaluate_subexp_do_call (exp, noside, callee, argvec,
+ nullptr, expect_type);
+}
+
+value *
+scope_operation::evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &args)
+{
+ if (!overload_resolution
+ || exp->language_defn->la_language != language_cplus)
+ return operation::evaluate_funcall (expect_type, exp, noside, args);
+
+ /* Unpack it locally so we can properly handle overload
+ resolution. */
+ const std::string &name = std::get<1> (m_storage);
+ struct type *type = std::get<0> (m_storage);
+
+ symbol *function = NULL;
+ const char *function_name = NULL;
+ std::vector<value *> argvec (1 + args.size ());
+ if (type->code () == TYPE_CODE_NAMESPACE)
+ {
+ function = cp_lookup_symbol_namespace (type->name (),
+ name.c_str (),
+ get_selected_block (0),
+ VAR_DOMAIN).symbol;
+ if (function == NULL)
+ error (_("No symbol \"%s\" in namespace \"%s\"."),
+ name.c_str (), type->name ());
+ }
+ else
+ {
+ gdb_assert (type->code () == TYPE_CODE_STRUCT
+ || type->code () == TYPE_CODE_UNION);
+ function_name = name.c_str ();
+
+ /* We need a properly typed value for method lookup. */
+ argvec[0] = value_zero (type, lval_memory);
+ }
+
+ for (int i = 0; i < args.size (); ++i)
+ argvec[i + 1] = args[i]->evaluate_with_coercion (exp, noside);
+ gdb::array_view<value *> arg_view = argvec;
+
+ value *callee = nullptr;
+ if (function_name != nullptr)
+ {
+ int static_memfuncp;
+
+ find_overload_match (arg_view, function_name, METHOD,
+ &argvec[0], nullptr, &callee, nullptr,
+ &static_memfuncp, 0, noside);
+ if (!static_memfuncp)
+ {
+ /* For the time being, we don't handle this. */
+ error (_("Call to overloaded function %s requires "
+ "`this' pointer"),
+ function_name);
+ }
+
+ arg_view = arg_view.slice (1);
+ }
+ else
+ {
+ symbol *symp;
+ arg_view = arg_view.slice (1);
+ find_overload_match (arg_view, nullptr,
+ NON_METHOD, nullptr, function,
+ nullptr, &symp, nullptr, 1, noside);
+ callee = value_of_variable (symp, get_selected_block (0));
+ }
+
+ return evaluate_subexp_do_call (exp, noside, callee, arg_view,
+ nullptr, expect_type);
+}
+
+value *
+structop_member_base::evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &args)
+{
+ /* First, evaluate the structure into lhs. */
+ value *lhs;
+ if (opcode () == STRUCTOP_MEMBER)
+ lhs = std::get<0> (m_storage)->evaluate_for_address (exp, noside);
+ else
+ lhs = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
+
+ std::vector<value *> vals (args.size () + 1);
+ gdb::array_view<value *> val_view = vals;
+ /* If the function is a virtual function, then the aggregate
+ value (providing the structure) plays its part by providing
+ the vtable. Otherwise, it is just along for the ride: call
+ the function directly. */
+ value *rhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
+ value *callee;
+
+ type *a1_type = check_typedef (value_type (rhs));
+ if (a1_type->code () == TYPE_CODE_METHODPTR)
+ {
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ callee = value_zero (TYPE_TARGET_TYPE (a1_type), not_lval);
+ else
+ callee = cplus_method_ptr_to_value (&lhs, rhs);
+
+ vals[0] = lhs;
+ }
+ else if (a1_type->code () == TYPE_CODE_MEMBERPTR)
+ {
+ struct type *type_ptr
+ = lookup_pointer_type (TYPE_SELF_TYPE (a1_type));
+ struct type *target_type_ptr
+ = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type));
+
+ /* Now, convert this value to an address. */
+ lhs = value_cast (type_ptr, lhs);
+
+ long mem_offset = value_as_long (rhs);
+
+ callee = value_from_pointer (target_type_ptr,
+ value_as_long (lhs) + mem_offset);
+ callee = value_ind (callee);
+
+ val_view = val_view.slice (1);
+ }
+ else
+ error (_("Non-pointer-to-member value used in pointer-to-member "
+ "construct"));
+
+ for (int i = 0; i < args.size (); ++i)
+ vals[i + 1] = args[i]->evaluate_with_coercion (exp, noside);
+
+ return evaluate_subexp_do_call (exp, noside, callee, val_view,
+ nullptr, expect_type);
+
+}
+
+value *
+structop_base_operation::evaluate_funcall
+ (struct type *expect_type, struct expression *exp, enum noside noside,
+ const std::vector<operation_up> &args)
+{
+ std::vector<value *> vals (args.size () + 1);
+ /* First, evaluate the structure into vals[0]. */
+ enum exp_opcode op = opcode ();
+ if (op == STRUCTOP_STRUCT)
+ {
+ /* If v is a variable in a register, and the user types
+ v.method (), this will produce an error, because v has no
+ address.
+
+ A possible way around this would be to allocate a copy of
+ the variable on the stack, copy in the contents, call the
+ function, and copy out the contents. I.e. convert this
+ from call by reference to call by copy-return (or
+ whatever it's called). However, this does not work
+ because it is not the same: the method being called could
+ stash a copy of the address, and then future uses through
+ that address (after the method returns) would be expected
+ to use the variable itself, not some copy of it. */
+ vals[0] = std::get<0> (m_storage)->evaluate_for_address (exp, noside);
+ }
+ else
+ {
+ vals[0] = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
+ /* Check to see if the operator '->' has been overloaded.
+ If the operator has been overloaded replace vals[0] with the
+ value returned by the custom operator and continue
+ evaluation. */
+ while (unop_user_defined_p (op, vals[0]))
+ {
+ struct value *value = nullptr;
+ try
+ {
+ value = value_x_unop (vals[0], op, noside);
+ }
+ catch (const gdb_exception_error &except)
+ {
+ if (except.error == NOT_FOUND_ERROR)
+ break;
+ else
+ throw;
+ }
+
+ vals[0] = value;
+ }
+ }
+
+ for (int i = 0; i < args.size (); ++i)
+ vals[i + 1] = args[i]->evaluate_with_coercion (exp, noside);
+ gdb::array_view<value *> arg_view = vals;
+
+ int static_memfuncp;
+ value *callee;
+ const char *tstr = std::get<1> (m_storage).c_str ();
+ if (overload_resolution
+ && exp->language_defn->la_language == language_cplus)
+ {
+ /* Language is C++, do some overload resolution before
+ evaluation. */
+ value *val0 = vals[0];
+ find_overload_match (arg_view, tstr, METHOD,
+ &val0, nullptr, &callee, nullptr,
+ &static_memfuncp, 0, noside);
+ vals[0] = val0;
+ }
+ else
+ /* Non-C++ case -- or no overload resolution. */
+ {
+ struct value *temp = vals[0];
+
+ callee = value_struct_elt (&temp, &vals[1], tstr,
+ &static_memfuncp,
+ op == STRUCTOP_STRUCT
+ ? "structure" : "structure pointer");
+ /* value_struct_elt updates temp with the correct value of the
+ ``this'' pointer if necessary, so modify it to reflect any
+ ``this'' changes. */
+ vals[0] = value_from_longest (lookup_pointer_type (value_type (temp)),
+ value_address (temp)
+ + value_embedded_offset (temp));
+ }
+
+ /* Take out `this' if needed. */
+ if (static_memfuncp)
+ arg_view = arg_view.slice (1);
+
+ return evaluate_subexp_do_call (exp, noside, callee, arg_view,
+ nullptr, expect_type);
+}
+
+
+} /* namespace expr */
+
/* Return true if type is integral or reference to integral */

static bool
diff --git a/gdb/expop.h b/gdb/expop.h
index 08e40345e76..de4b876de39 100644
--- a/gdb/expop.h
+++ b/gdb/expop.h
@@ -594,6 +594,11 @@ class scope_operation
value *evaluate_for_address (struct expression *exp,
enum noside noside) override;

+ value *evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &args) override;
+
enum exp_opcode opcode () const override
{ return OP_SCOPE; }

@@ -631,6 +636,11 @@ class var_value_operation
value *evaluate_for_address (struct expression *exp, enum noside noside)
override;

+ value *evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &args) override;
+
enum exp_opcode opcode () const override
{ return OP_VAR_VALUE; }

@@ -971,6 +981,11 @@ class structop_base_operation
EVAL_AVOID_SIDE_EFFECTS);
}

+ value *evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &args) override;
+
protected:

using tuple_holding_operation::tuple_holding_operation;
@@ -1044,13 +1059,26 @@ class structop_ptr_operation
}
};

-class structop_member_operation
+class structop_member_base
: public tuple_holding_operation<operation_up, operation_up>
{
public:

using tuple_holding_operation::tuple_holding_operation;

+ value *evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &args) override;
+};
+
+class structop_member_operation
+ : public structop_member_base
+{
+public:
+
+ using structop_member_base::structop_member_base;
+
value *evaluate (struct type *expect_type,
struct expression *exp,
enum noside noside) override
@@ -1067,11 +1095,11 @@ class structop_member_operation
};

class structop_mptr_operation
- : public tuple_holding_operation<operation_up, operation_up>
+ : public structop_member_base
{
public:

- using tuple_holding_operation::tuple_holding_operation;
+ using structop_member_base::structop_member_base;

value *evaluate (struct type *expect_type,
struct expression *exp,
@@ -2068,6 +2096,27 @@ class array_operation
enum noside noside, int nargs);
};

+/* A function call. This holds the callee operation and the
+ arguments. */
+class funcall_operation
+ : public tuple_holding_operation<operation_up, std::vector<operation_up>>
+{
+public:
+
+ using tuple_holding_operation::tuple_holding_operation;
+
+ value *evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside) override
+ {
+ return std::get<0> (m_storage)->evaluate_funcall (expect_type, exp, noside,
+ std::get<1> (m_storage));
+ }
+
+ enum exp_opcode opcode () const override
+ { return OP_FUNCALL; }
+};
+
} /* namespace expr */

#endif /* EXPOP_H */
diff --git a/gdb/expression.h b/gdb/expression.h
index 08a6424fdd2..a850f64d160 100644
--- a/gdb/expression.h
+++ b/gdb/expression.h
@@ -144,6 +144,15 @@ class operation
virtual value *evaluate_for_address (struct expression *exp,
enum noside noside);

+ /* Evaluate a function call, with this object as the callee.
+ EXPECT_TYPE, EXP, and NOSIDE have the same meaning as in
+ 'evaluate'. ARGS holds the operations that should be evaluated
+ to get the arguments to the call. */
+ virtual value *evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &args);
+
/* True if this is a constant expression. */
virtual bool constant_p () const
{ return false; }
--
2.26.2