/* 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 "interps.h"
#include "thread-fsm.h"
#include <algorithm>
-#include "common/scope-exit.h"
+#include "gdbsupport/scope-exit.h"
+#include <list>
/* If we can't find a function's name from its address,
we print this instead. */
asynchronous inferior function call implementation, and that in
turn means restructuring the code so that it is event driven. */
+static bool may_call_functions_p = true;
+static void
+show_may_call_functions_p (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ fprintf_filtered (file,
+ _("Permission to call functions in the program is %s.\n"),
+ value);
+}
+
/* How you should pass arguments to a function depends on whether it
was defined in K&R style or prototype style. If you define a
function using the K&R syntax that takes a `float' argument, then
trust the debug information; the user can override this behavior
with "set coerce-float-to-double 0". */
-static int coerce_float_to_double_p = 1;
+static bool coerce_float_to_double_p = true;
static void
show_coerce_float_to_double_p (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
The default is to stop in the frame where the signal was received. */
-static int unwind_on_signal_p = 0;
+static bool unwind_on_signal_p = false;
static void
show_unwind_on_signal_p (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
The default is to unwind the frame if a std::terminate call is
made. */
-static int unwind_on_terminating_exception_p = 1;
+static bool unwind_on_terminating_exception_p = true;
static void
show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty,
for arguments to be passed to C, Ada or Fortran functions.
If PARAM_TYPE is non-NULL, it is the expected parameter type.
- IS_PROTOTYPED is non-zero if the function declaration is prototyped.
- SP is the stack pointer were additional data can be pushed (updating
- its value as needed). */
+ IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
static struct value *
value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
- struct type *param_type, int is_prototyped, CORE_ADDR *sp)
+ struct type *param_type, int is_prototyped)
{
const struct builtin_type *builtin = builtin_type (gdbarch);
struct type *arg_type = check_typedef (value_type (arg));
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)
{
run_inferior_call (struct call_thread_fsm *sm,
struct thread_info *call_thread, CORE_ADDR real_pc)
{
- struct gdb_exception caught_error = exception_none;
+ struct gdb_exception caught_error;
int saved_in_infcall = call_thread->control.in_infcall;
ptid_t call_thread_ptid = call_thread->ptid;
enum prompt_state saved_prompt_state = current_ui->prompt_state;
target supports asynchronous execution. */
wait_sync_command_done ();
}
- catch (const gdb_exception_RETURN_MASK_ALL &e)
+ catch (gdb_exception &e)
{
- caught_error = e;
+ caught_error = std::move (e);
}
/* If GDB has the prompt blocked before, then ensure that it remains
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 caught_error;
}
+/* Reserve space on the stack for a value of the given type.
+ Return the address of the allocated space.
+ Make certain that the value is correctly aligned.
+ The SP argument is modified. */
+
+static CORE_ADDR
+reserve_stack_space (const type *values_type, CORE_ADDR &sp)
+{
+ struct frame_info *frame = get_current_frame ();
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+ CORE_ADDR addr = 0;
+
+ if (gdbarch_inner_than (gdbarch, 1, 2))
+ {
+ /* Stack grows downward. Align STRUCT_ADDR and SP after
+ making space. */
+ sp -= TYPE_LENGTH (values_type);
+ if (gdbarch_frame_align_p (gdbarch))
+ sp = gdbarch_frame_align (gdbarch, sp);
+ addr = sp;
+ }
+ else
+ {
+ /* Stack grows upward. Align the frame, allocate space, and
+ then again, re-align the frame??? */
+ if (gdbarch_frame_align_p (gdbarch))
+ sp = gdbarch_frame_align (gdbarch, sp);
+ addr = sp;
+ sp += TYPE_LENGTH (values_type);
+ if (gdbarch_frame_align_p (gdbarch))
+ sp = gdbarch_frame_align (gdbarch, sp);
+ }
+
+ 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 *
making dummy frames be different from normal frames, consider that. */
/* Perform a function call in the inferior.
- ARGS is a vector of values of arguments (NARGS of them).
+ ARGS is a vector of values of arguments.
FUNCTION is a value, the function to be called.
Returns a value representing what the function returned.
May fail to return, if a breakpoint or signal is hit
struct gdb_exception e;
char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
+ if (!may_call_functions_p)
+ error (_("Cannot call functions in the program: "
+ "may-call-functions is off."));
+
if (!target_has_execution)
noprocess ();
if (!gdbarch_push_dummy_call_p (gdbarch))
error (_("This target does not support function calls."));
+ /* Find the function type and do a sanity check. */
+ type *ftype;
+ type *values_type;
+ CORE_ADDR funaddr = find_function_addr (function, &values_type, &ftype);
+
+ if (values_type == NULL)
+ values_type = default_return_type;
+ if (values_type == NULL)
+ {
+ const char *name = get_function_name (funaddr,
+ name_buf, sizeof (name_buf));
+ error (_("'%s' has unknown return type; "
+ "cast the call to its declared return type"),
+ name);
+ }
+
+ values_type = check_typedef (values_type);
+
+ if (args.size () < ftype->num_fields ())
+ error (_("Too few arguments in function call."));
+
/* A holder for the inferior status.
This is only needed while we're preparing the inferior function call. */
infcall_control_state_up inf_status (save_infcall_control_state ());
void parameterless generic dummy frame calls to frameless
functions will create a sequence of effectively identical
frames (SP, FP and TOS and PC the same). This, not
- suprisingly, results in what appears to be a stack in an
+ surprisingly, results in what appears to be a stack in an
infinite loop --- when GDB tries to find a generic dummy
frame on the internal dummy frame stack, it will always
find the first one.
}
}
- type *ftype;
- type *values_type;
- CORE_ADDR funaddr = find_function_addr (function, &values_type, &ftype);
-
- if (values_type == NULL)
- values_type = default_return_type;
- if (values_type == NULL)
- {
- const char *name = get_function_name (funaddr,
- name_buf, sizeof (name_buf));
- error (_("'%s' has unknown return type; "
- "cast the call to its declared return type"),
- name);
- }
-
- values_type = check_typedef (values_type);
-
/* Are we returning a value using a structure return? */
if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type))
internal_error (__FILE__, __LINE__, _("bad switch"));
}
- if (args.size () < TYPE_NFIELDS (ftype))
- error (_("Too few arguments in function call."));
+ /* 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--)
{
/* 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))
+ if (i < ftype->num_fields ())
param_type = TYPE_FIELD_TYPE (ftype, i);
else
param_type = NULL;
+ value *original_arg = args[i];
args[i] = value_arg_coerce (gdbarch, args[i],
- param_type, prototyped, &sp);
+ param_type, prototyped);
+
+ 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);
+ }
- if (param_type != NULL && language_pass_by_reference (param_type))
- args[i] = value_addr (args[i]);
+ args[i] = clone_ptr;
}
/* Reserve space for the return structure to be written on the
- stack, if necessary. Make certain that the value is correctly
- aligned.
+ stack, if necessary.
While evaluating expressions, we reserve space on the stack for
return values of class type even if the language ABI and the target
if (return_method != return_method_normal
|| (stack_temporaries && class_or_union_p (values_type)))
- {
- if (gdbarch_inner_than (gdbarch, 1, 2))
- {
- /* Stack grows downward. Align STRUCT_ADDR and SP after
- making space for the return value. */
- sp -= TYPE_LENGTH (values_type);
- if (gdbarch_frame_align_p (gdbarch))
- sp = gdbarch_frame_align (gdbarch, sp);
- struct_addr = sp;
- }
- else
- {
- /* Stack grows upward. Align the frame, allocate space, and
- then again, re-align the frame??? */
- if (gdbarch_frame_align_p (gdbarch))
- sp = gdbarch_frame_align (gdbarch, sp);
- struct_addr = sp;
- sp += TYPE_LENGTH (values_type);
- if (gdbarch_frame_align_p (gdbarch))
- sp = gdbarch_frame_align (gdbarch, sp);
- }
- }
+ struct_addr = reserve_stack_space (values_type, sp);
std::vector<struct value *> new_args;
if (return_method == return_method_hidden_param)
maybe_remove_breakpoints ();
gdb_assert (retval != NULL);
+
+ /* Destruct the pass-by-ref argument clones. */
+ call_destructors (dtors_to_invoke, default_return_type);
+
return retval;
}
e.what (), name);
case RETURN_QUIT:
default:
- throw_exception (e);
+ throw_exception (std::move (e));
}
}
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, _("\
+Set permission to call functions in the program."), _("\
+Show permission to call functions in the program."), _("\
+When this permission is on, GDB may call functions in the program.\n\
+Otherwise, any sort of attempt to call a function in the program\n\
+will result in an error."),
+ NULL,
+ show_may_call_functions_p,
+ &setlist, &showlist);
+
add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
&coerce_float_to_double_p, _("\
Set coercion of floats to doubles when calling functions."), _("\
-Show coercion of floats to doubles when calling functions"), _("\
+Show coercion of floats to doubles when calling functions."), _("\
Variables of type float should generally be converted to doubles before\n\
calling an unprototyped function, and left alone when calling a prototyped\n\
function. However, some older debug info formats do not provide enough\n\
information to determine that a function is prototyped. If this flag is\n\
set, GDB will perform the conversion for a function it considers\n\
unprototyped.\n\
-The default is to perform the conversion.\n"),
+The default is to perform the conversion."),
NULL,
show_coerce_float_to_double_p,
&setlist, &showlist);
projects / deliverable / binutils-gdb.git / blobdiff