/* Perform an inferior function call, for GDB, the GNU debugger.
- Copyright (C) 1986-2016 Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 Free Software Foundation, Inc.
This file is part of GDB.
#include "ada-lang.h"
#include "gdbthread.h"
#include "event-top.h"
-#include "observer.h"
+#include "observable.h"
#include "top.h"
#include "interps.h"
#include "thread-fsm.h"
+#include <algorithm>
/* If we can't find a function's name from its address,
we print this instead. */
Unfortunately, on certain older platforms, the debug info doesn't
indicate reliably how each function was defined. A function type's
- TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
- defined in prototype style. When calling a function whose
- TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
- decide what to do.
+ TYPE_PROTOTYPED flag may be clear, even if the function was defined
+ in prototype style. When calling a function whose TYPE_PROTOTYPED
+ flag is clear, GDB consults this flag to decide what to do.
For modern targets, it is proper to assume that, if the prototype
flag is clear, that can be trusted: `float' arguments should be
switch (TYPE_CODE (type))
{
case TYPE_CODE_REF:
+ case TYPE_CODE_RVALUE_REF:
{
struct value *new_value;
- if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
+ if (TYPE_IS_REFERENCE (arg_type))
return value_cast_pointers (type, arg, 0);
/* Cast the value to the reference's target type, and then
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);
+ new_value = value_ref (new_value, TYPE_CODE (type));
return new_value;
}
case TYPE_CODE_INT:
regcache);
}
+/* See infcall.h. */
+
+void
+error_call_unknown_return_type (const char *func_name)
+{
+ if (func_name != NULL)
+ error (_("'%s' has unknown return type; "
+ "cast the call to its declared return type"),
+ func_name);
+ else
+ error (_("function has unknown return type; "
+ "cast the call to its declared return type"));
+}
+
/* Fetch the name of the function at FUNADDR.
This is used in printing an error message for call_function_by_hand.
BUF is used to print FUNADDR in hex if the function name cannot be
/* If using a structure return, this is the structure's address. */
CORE_ADDR struct_addr;
-
- /* Whether stack temporaries are enabled. */
- int stack_temporaries_enabled;
};
/* Extract the called function's return value. */
get_call_return_value (struct call_return_meta_info *ri)
{
struct value *retval = NULL;
- int stack_temporaries = thread_stack_temporaries_enabled_p (inferior_ptid);
+ bool stack_temporaries = thread_stack_temporaries_enabled_p (inferior_ptid);
if (TYPE_CODE (ri->value_type) == TYPE_CODE_VOID)
retval = allocate_value (ri->value_type);
if (stop_stack_dummy == STOP_STACK_DUMMY)
{
- struct cleanup *old_chain;
-
/* Done. */
thread_fsm_set_finished (self);
f->return_value = get_call_return_value (&f->return_meta_info);
/* Break out of wait_sync_command_done. */
- old_chain = make_cleanup (restore_ui_cleanup, current_ui);
- current_ui = f->waiting_ui;
- target_terminal_ours ();
+ scoped_restore save_ui = make_scoped_restore (¤t_ui, f->waiting_ui);
+ target_terminal::ours ();
f->waiting_ui->prompt_state = PROMPT_NEEDED;
-
- /* This restores the previous UI. */
- do_cleanups (old_chain);
}
return 1;
fetch_inferior_event. */
current_ui->async = 0;
+ delete_file_handler (current_ui->input_fd);
+
call_thread->control.in_infcall = 1;
clear_proceed_status (0);
state again here. In other cases, stdin will be re-enabled by
inferior_event_handler, when an exception is thrown. */
current_ui->prompt_state = saved_prompt_state;
+ if (current_ui->prompt_state == PROMPT_BLOCKED)
+ delete_file_handler (current_ui->input_fd);
+ else
+ ui_register_input_event_handler (current_ui);
current_ui->async = saved_ui_async;
/* At this point the current thread may have changed. Refresh
/* See infcall.h. */
struct value *
-call_function_by_hand (struct value *function, int nargs, struct value **args)
+call_function_by_hand (struct value *function,
+ type *default_return_type,
+ int nargs, struct value **args)
{
- return call_function_by_hand_dummy (function, nargs, args, NULL, NULL);
+ return call_function_by_hand_dummy (function, default_return_type,
+ nargs, args, NULL, NULL);
}
/* All this stuff with a dummy frame may seem unnecessarily complicated
struct value *
call_function_by_hand_dummy (struct value *function,
+ type *default_return_type,
int nargs, struct value **args,
dummy_frame_dtor_ftype *dummy_dtor,
void *dummy_dtor_data)
struct type *ftype = check_typedef (value_type (function));
CORE_ADDR bp_addr;
struct frame_id dummy_id;
- struct cleanup *args_cleanup;
struct frame_info *frame;
struct gdbarch *gdbarch;
struct cleanup *terminate_bp_cleanup;
ptid_t call_thread_ptid;
struct gdb_exception e;
char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
- int stack_temporaries = thread_stack_temporaries_enabled_p (inferior_ptid);
+ bool stack_temporaries = thread_stack_temporaries_enabled_p (inferior_ptid);
if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
}
funaddr = find_function_addr (function, &values_type);
- if (!values_type)
- values_type = builtin_type (gdbarch)->builtin_int;
+ 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);
target_values_type = values_type;
}
- observer_notify_inferior_call_pre (inferior_ptid, funaddr);
+ gdb::observers::inferior_call_pre.notify (inferior_ptid, funaddr);
/* Determine the location of the breakpoint (and possibly other
stuff) that the called function will return to. The SPARC, for a
prototyped. Can we respect TYPE_VARARGS? Probably not. */
if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
prototyped = 1;
+ if (TYPE_TARGET_TYPE (ftype) == NULL && TYPE_NFIELDS (ftype) == 0
+ && default_return_type != NULL)
+ {
+ /* Calling a no-debug function with the return type
+ explicitly cast. Assume the function is prototyped,
+ with a prototype matching the types of the arguments.
+ E.g., with:
+ float mult (float v1, float v2) { return v1 * v2; }
+ This:
+ (gdb) p (float) mult (2.0f, 3.0f)
+ Is a simpler alternative to:
+ (gdb) p ((float (*) (float, float)) mult) (2.0f, 3.0f)
+ */
+ prototyped = 1;
+ }
else if (i < TYPE_NFIELDS (ftype))
prototyped = TYPE_PROTOTYPED (ftype);
else
}
}
+ std::vector<struct value *> new_args;
if (hidden_first_param_p)
{
- struct value **new_args;
-
/* Add the new argument to the front of the argument list. */
- new_args = XNEWVEC (struct value *, nargs + 1);
- new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
- struct_addr);
- memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
- args = new_args;
+ new_args.push_back
+ (value_from_pointer (lookup_pointer_type (values_type), struct_addr));
+ std::copy (&args[0], &args[nargs], std::back_inserter (new_args));
+ args = new_args.data ();
nargs++;
- args_cleanup = make_cleanup (xfree, args);
}
- else
- args_cleanup = make_cleanup (null_cleanup, NULL);
/* Create the dummy stack frame. Pass in the call dummy address as,
presumably, the ABI code knows where, in the call dummy, the
bp_addr, nargs, args,
sp, struct_return, struct_addr);
- do_cleanups (args_cleanup);
-
/* Set up a frame ID for the dummy frame so we can pass it to
set_momentary_breakpoint. We need to give the breakpoint a frame
ID so that the breakpoint code can correctly re-identify the
inferior. That way it breaks when it returns. */
{
- struct breakpoint *bpt, *longjmp_b;
- struct symtab_and_line sal;
-
- init_sal (&sal); /* initialize to zeroes */
+ symtab_and_line sal;
sal.pspace = current_program_space;
sal.pc = bp_addr;
sal.section = find_pc_overlay (sal.pc);
+
/* Sanity. The exact same SP value is returned by
PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
dummy_id to form the frame ID's stack address. */
- bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
+ breakpoint *bpt
+ = set_momentary_breakpoint (gdbarch, sal,
+ dummy_id, bp_call_dummy).release ();
/* set_momentary_breakpoint invalidates FRAME. */
frame = NULL;
bpt->disposition = disp_del;
gdb_assert (bpt->related_breakpoint == bpt);
- longjmp_b = set_longjmp_breakpoint_for_call_dummy ();
+ breakpoint *longjmp_b = set_longjmp_breakpoint_for_call_dummy ();
if (longjmp_b)
{
/* Link BPT into the chain of LONGJMP_B. */
e = run_inferior_call (sm, tp, real_pc);
- observer_notify_inferior_call_post (call_thread_ptid, funaddr);
+ gdb::observers::inferior_call_post.notify (call_thread_ptid, funaddr);
tp = find_thread_ptid (call_thread_ptid);
if (tp != NULL)
{
/* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
- char *name = xstrdup (get_function_name (funaddr,
- name_buf, sizeof (name_buf)));
- make_cleanup (xfree, name);
-
+ std::string name = get_function_name (funaddr, name_buf,
+ sizeof (name_buf));
if (stopped_by_random_signal)
{
To change this behavior use \"set unwindonsignal off\".\n\
Evaluation of the expression containing the function\n\
(%s) will be abandoned."),
- name);
+ name.c_str ());
}
else
{
Evaluation of the expression containing the function\n\
(%s) will be abandoned.\n\
When the function is done executing, GDB will silently stop."),
- name);
+ name.c_str ());
}
}
To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
Evaluation of the expression containing the function (%s)\n\
will be abandoned."),
- name);
+ name.c_str ());
}
else if (stop_stack_dummy == STOP_NONE)
{
Evaluation of the expression containing the function\n\
(%s) will be abandoned.\n\
When the function is done executing, GDB will silently stop."),
- name);
+ name.c_str ());
}
}
/* The above code errors out, so ... */
gdb_assert_not_reached ("... should not be here");
}
-\f
-
-/* Provide a prototype to silence -Wmissing-prototypes. */
-void _initialize_infcall (void);
void
_initialize_infcall (void)
projects / deliverable / binutils-gdb.git / blobdiff