/* Perform an inferior function call, for GDB, the GNU debugger.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "thread-fsm.h"
#include <algorithm>
#include "gdbsupport/scope-exit.h"
+#include <list>
/* If we can't find a function's name from its address,
we print this instead. */
saved by the called function. */
arg = value_coerce_to_target (arg);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_REF:
case TYPE_CODE_RVALUE_REF:
if the value was not previously in memory - in some cases
we should clearly be allowing this, but how? */
new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
- new_value = value_ref (new_value, TYPE_CODE (type));
+ new_value = value_ref (new_value, type->code ());
return new_value;
}
case TYPE_CODE_INT:
part of it. */
/* Determine address to call. */
- if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
- || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+ if (ftype->code () == TYPE_CODE_FUNC
+ || ftype->code () == TYPE_CODE_METHOD)
funaddr = value_address (function);
- else if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
+ else if (ftype->code () == TYPE_CODE_PTR)
{
funaddr = value_as_address (function);
ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
- if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
- || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+ if (ftype->code () == TYPE_CODE_FUNC
+ || ftype->code () == TYPE_CODE_METHOD)
funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
current_top_target ());
}
- if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
- || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+ if (ftype->code () == TYPE_CODE_FUNC
+ || ftype->code () == TYPE_CODE_METHOD)
{
if (TYPE_GNU_IFUNC (ftype))
{
else
value_type = TYPE_TARGET_TYPE (ftype);
}
- else if (TYPE_CODE (ftype) == TYPE_CODE_INT)
+ else if (ftype->code () == TYPE_CODE_INT)
{
/* Handle the case of functions lacking debugging info.
Their values are characters since their addresses are char. */
struct symbol *symbol = find_pc_function (funaddr);
if (symbol)
- return SYMBOL_PRINT_NAME (symbol);
+ return symbol->print_name ();
}
{
struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr);
if (msymbol.minsym)
- return MSYMBOL_PRINT_NAME (msymbol.minsym);
+ return msymbol.minsym->print_name ();
}
{
thread_info *thr = inferior_thread ();
bool stack_temporaries = thread_stack_temporaries_enabled_p (thr);
- if (TYPE_CODE (ri->value_type) == TYPE_CODE_VOID)
+ if (ri->value_type->code () == TYPE_CODE_VOID)
retval = allocate_value (ri->value_type);
else if (ri->struct_return_p)
{
if (!was_running
&& call_thread_ptid == inferior_ptid
&& stop_stack_dummy == STOP_STACK_DUMMY)
- finish_thread_state (user_visible_resume_ptid (0));
+ finish_thread_state (call_thread->inf->process_target (),
+ user_visible_resume_ptid (0));
enable_watchpoints_after_interactive_call_stop ();
return addr;
}
+/* The data structure which keeps a destructor function and
+ its implicit 'this' parameter. */
+
+struct destructor_info
+{
+ destructor_info (struct value *function, struct value *self)
+ : function (function), self (self) { }
+
+ struct value *function;
+ struct value *self;
+};
+
+
+/* Auxiliary function that takes a list of destructor functions
+ with their 'this' parameters, and invokes the functions. */
+
+static void
+call_destructors (const std::list<destructor_info> &dtors_to_invoke,
+ struct type *default_return_type)
+{
+ for (auto vals : dtors_to_invoke)
+ {
+ call_function_by_hand (vals.function, default_return_type,
+ gdb::make_array_view (&(vals.self), 1));
+ }
+}
+
/* See infcall.h. */
struct value *
values_type = check_typedef (values_type);
- if (args.size () < TYPE_NFIELDS (ftype))
+ if (args.size () < ftype->num_fields ())
error (_("Too few arguments in function call."));
/* A holder for the inferior status.
internal_error (__FILE__, __LINE__, _("bad switch"));
}
+ /* Coerce the arguments and handle pass-by-reference.
+ We want to remember the destruction required for pass-by-ref values.
+ For these, store the dtor function and the 'this' argument
+ in DTORS_TO_INVOKE. */
+ std::list<destructor_info> dtors_to_invoke;
+
for (int i = args.size () - 1; i >= 0; i--)
{
int prototyped;
/* FIXME drow/2002-05-31: Should just always mark methods as
prototyped. Can we respect TYPE_VARARGS? Probably not. */
- if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+ if (ftype->code () == TYPE_CODE_METHOD)
prototyped = 1;
- if (TYPE_TARGET_TYPE (ftype) == NULL && TYPE_NFIELDS (ftype) == 0
+ if (TYPE_TARGET_TYPE (ftype) == NULL && ftype->num_fields () == 0
&& default_return_type != NULL)
{
/* Calling a no-debug function with the return type
*/
prototyped = 1;
}
- else if (i < TYPE_NFIELDS (ftype))
+ else if (i < ftype->num_fields ())
prototyped = TYPE_PROTOTYPED (ftype);
else
prototyped = 0;
- if (i < TYPE_NFIELDS (ftype))
- param_type = TYPE_FIELD_TYPE (ftype, i);
+ if (i < ftype->num_fields ())
+ param_type = ftype->field (i).type ();
else
param_type = NULL;
+ value *original_arg = args[i];
args[i] = value_arg_coerce (gdbarch, args[i],
param_type, prototyped);
- if (param_type != NULL && language_pass_by_reference (param_type))
- args[i] = value_addr (args[i]);
+ if (param_type == NULL)
+ continue;
+
+ auto info = language_pass_by_reference (param_type);
+ if (!info.copy_constructible)
+ error (_("expression cannot be evaluated because the type '%s' "
+ "is not copy constructible"), param_type->name ());
+
+ if (!info.destructible)
+ error (_("expression cannot be evaluated because the type '%s' "
+ "is not destructible"), param_type->name ());
+
+ if (info.trivially_copyable)
+ continue;
+
+ /* Make a copy of the argument on the stack. If the argument is
+ trivially copy ctor'able, copy bit by bit. Otherwise, call
+ the copy ctor to initialize the clone. */
+ CORE_ADDR addr = reserve_stack_space (param_type, sp);
+ value *clone
+ = value_from_contents_and_address (param_type, nullptr, addr);
+ push_thread_stack_temporary (call_thread.get (), clone);
+ value *clone_ptr
+ = value_from_pointer (lookup_pointer_type (param_type), addr);
+
+ if (info.trivially_copy_constructible)
+ {
+ int length = TYPE_LENGTH (param_type);
+ write_memory (addr, value_contents (args[i]), length);
+ }
+ else
+ {
+ value *copy_ctor;
+ value *cctor_args[2] = { clone_ptr, original_arg };
+ find_overload_match (gdb::make_array_view (cctor_args, 2),
+ param_type->name (), METHOD,
+ &clone_ptr, nullptr, ©_ctor, nullptr,
+ nullptr, 0, EVAL_NORMAL);
+
+ if (copy_ctor == nullptr)
+ error (_("expression cannot be evaluated because a copy "
+ "constructor for the type '%s' could not be found "
+ "(maybe inlined?)"), param_type->name ());
+
+ call_function_by_hand (copy_ctor, default_return_type,
+ gdb::make_array_view (cctor_args, 2));
+ }
+
+ /* If the argument has a destructor, remember it so that we
+ invoke it after the infcall is complete. */
+ if (!info.trivially_destructible)
+ {
+ /* Looking up the function via overload resolution does not
+ work because the compiler (in particular, gcc) adds an
+ artificial int parameter in some cases. So we look up
+ the function by using the "~" name. This should be OK
+ because there can be only one dtor definition. */
+ const char *dtor_name = nullptr;
+ for (int fieldnum = 0;
+ fieldnum < TYPE_NFN_FIELDS (param_type);
+ fieldnum++)
+ {
+ fn_field *fn
+ = TYPE_FN_FIELDLIST1 (param_type, fieldnum);
+ const char *field_name
+ = TYPE_FN_FIELDLIST_NAME (param_type, fieldnum);
+
+ if (field_name[0] == '~')
+ dtor_name = TYPE_FN_FIELD_PHYSNAME (fn, 0);
+ }
+
+ if (dtor_name == nullptr)
+ error (_("expression cannot be evaluated because a destructor "
+ "for the type '%s' could not be found "
+ "(maybe inlined?)"), param_type->name ());
+
+ value *dtor
+ = find_function_in_inferior (dtor_name, 0);
+
+ /* Insert the dtor to the front of the list to call them
+ in reverse order later. */
+ dtors_to_invoke.emplace_front (dtor, clone_ptr);
+ }
+
+ args[i] = clone_ptr;
}
/* Reserve space for the return structure to be written on the
maybe_remove_breakpoints ();
gdb_assert (retval != NULL);
+
+ /* Destruct the pass-by-ref argument clones. */
+ call_destructors (dtors_to_invoke, default_return_type);
+
return retval;
}
gdb_assert_not_reached ("... should not be here");
}
+void _initialize_infcall ();
void
-_initialize_infcall (void)
+_initialize_infcall ()
{
add_setshow_boolean_cmd ("may-call-functions", no_class,
&may_call_functions_p, _("\
projects / deliverable / binutils-gdb.git / blobdiff