static void
metrowerks_step_command (char *args, int from_tty)
{
int async_exec = 0;
CORE_ADDR range_start = 0;
CORE_ADDR range_stop = 0;
int step_into = 0;
int num_args = 0;
char **argv = NULL;
if (args != NULL)
async_exec = strip_bg_char (&args);
if (event_loop_p && async_exec && !target_can_async_p ())
error ("Asynchronous execution not supported on this target.");
/* If we do NOT get a request of running in the bg, then we need
* to simulate synchronous (fg) execution. */
if (event_loop_p && !async_exec && target_can_async_p ())
{
async_disable_stdin ();
}
argv = buildargv (args);
if (argv == NULL)
{
num_args = 0;
}
else
{
num_args = 0;
while (argv[num_args] != NULL)
num_args++;
}
if (num_args != 3 && num_args != 5)
error ("Usage: metrowerks-step <start> <stop> <step-into> ?<func_start> <func_end>?");
range_start = strtoul (argv[0], NULL, 16);
range_stop = strtoul (argv[1], NULL, 16);
step_into = strtoul (argv[2], NULL, 16);
if (num_args == 5)
{
metrowerks_step_func_start = strtoul (argv[3], NULL, 16);
metrowerks_step_func_end = strtoul (argv[4], NULL, 16);
}
else
{
metrowerks_step_func_start = 0;
metrowerks_step_func_end = 0;
}
if (!target_has_execution)
error ("The program is not being run.");
metrowerks_step (range_start, range_stop, step_into);
}
static struct gdb_exception
run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc)
{
volatile struct gdb_exception e;
int saved_in_infcall = call_thread->control.in_infcall;
ptid_t call_thread_ptid = call_thread->ptid;
int saved_sync_execution = sync_execution;
/* Infcalls run synchronously, in the foreground. */
if (target_can_async_p ())
sync_execution = 1;
call_thread->control.in_infcall = 1;
clear_proceed_status ();
disable_watchpoints_before_interactive_call_start ();
/* We want stop_registers, please... */
call_thread->control.proceed_to_finish = 1;
TRY_CATCH (e, RETURN_MASK_ALL)
{
int was_sync = sync_execution;
proceed (real_pc, GDB_SIGNAL_0, 0);
/* Inferior function calls are always synchronous, even if the
target supports asynchronous execution. Do here what
`proceed' itself does in sync mode. */
if (target_can_async_p ())
{
wait_for_inferior ();
normal_stop ();
/* If GDB was previously in sync execution mode, then ensure
that it remains so. normal_stop calls
async_enable_stdin, so reset it again here. In other
cases, stdin will be re-enabled by
inferior_event_handler, when an exception is thrown. */
if (was_sync)
async_disable_stdin ();
}
}
