From 8517f62b166073b871c896fdd642798fae4a08bd Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Fri, 18 Apr 1997 12:24:52 +0000 Subject: Ref gdb/11763 - can't stop a running simulator: o Provide poll_quit callback to simulators so that they can poll for SIGINT on clueless OS's. o Add sim_stop to simulators so that clients can request a halt (eg gdbtk's STOP button) Works for PPC! o Re-arange remote-sim.c so that the hard work is moved from gdbsim_resume() to gdbsim_wait() (where it should be). --- sim/arm/ChangeLog | 4 + sim/common/ChangeLog | 16 ++ sim/common/run.c | 15 +- sim/common/sim-events.c | 400 ++++++++++++++++++++++++++++++++++++++++++++++++ sim/d10v/ChangeLog | 4 + sim/d10v/interp.c | 9 ++ sim/h8300/ChangeLog | 5 + sim/mn10300/ChangeLog | 4 + sim/ppc/ChangeLog | 23 +++ sim/ppc/main.c | 21 ++- sim/sh/ChangeLog | 5 + sim/sh/interp.c | 34 ++-- sim/v850/ChangeLog | 4 + sim/v850/interp.c | 7 + 14 files changed, 527 insertions(+), 24 deletions(-) create mode 100644 sim/common/sim-events.c (limited to 'sim') diff --git a/sim/arm/ChangeLog b/sim/arm/ChangeLog index 1d56c44..28314dd 100644 --- a/sim/arm/ChangeLog +++ b/sim/arm/ChangeLog @@ -1,3 +1,7 @@ +Fri Apr 18 13:32:23 1997 Andrew Cagney + + * wrapper.c (sim_stop): Stub sim_stop function. + Thu Apr 17 18:33:01 1997 Fred Fish * arminit.c (ARMul_NewState): Preinitialize the state to diff --git a/sim/common/ChangeLog b/sim/common/ChangeLog index f285cb1..49500ac 100644 --- a/sim/common/ChangeLog +++ b/sim/common/ChangeLog @@ -1,3 +1,19 @@ +Fri Apr 18 13:11:36 1997 Andrew Cagney + + * run.c (main, cntrl_c): Wrap calls to sim_resume in a SIGINT + handler that calls sim_stop (). Simulators may still be + establishing their own handler. + + * sim-events.c (sim_events_poll): Rename from + sim_events_at_large_int. Poll IO. + + * sim-io.c (sim_io_poll_quit): New function - pass on a polling + request. + + * callback.c (os_poll_quit): New function poll for quit signal + where needed. + (default_callback): Include magic number. + Thu Apr 17 02:25:11 1997 Doug Evans * aclocal.m4: Check for headers time.h, sys/time.h, sys/resource.h. diff --git a/sim/common/run.c b/sim/common/run.c index 24dfe20..acdbab2 100644 --- a/sim/common/run.c +++ b/sim/common/run.c @@ -63,12 +63,24 @@ extern int sim_trace PARAMS ((SIM_DESC sd)); extern int getopt (); +static SIM_DESC sd; + +static RETSIGTYPE +cntrl_c (int sig) +{ + if (! sim_stop (sd)) + { + fprintf (stderr, "Quit!\n"); + exit (1); + } +} int main (ac, av) int ac; char **av; { + RETSIGTYPE (*prev_sigint) (); bfd *abfd; asection *s; int i; @@ -80,7 +92,6 @@ main (ac, av) char **prog_args; enum sim_stop reason; int sigrc; - SIM_DESC sd; myname = av[0] + strlen (av[0]); while (myname > av[0] && myname[-1] != '/') @@ -207,6 +218,7 @@ main (ac, av) if (sim_create_inferior (sd, prog_args, NULL) == SIM_RC_FAIL) exit (1); + prev_sigint = signal (SIGINT, cntrl_c); if (trace) { int done = 0; @@ -219,6 +231,7 @@ main (ac, av) { sim_resume (sd, 0, 0); } + signal (SIGINT, prev_sigint); if (verbose) sim_info (sd, 0); diff --git a/sim/common/sim-events.c b/sim/common/sim-events.c new file mode 100644 index 0000000..60927c0 --- /dev/null +++ b/sim/common/sim-events.c @@ -0,0 +1,400 @@ +/* This file is part of the program psim. + + Copyright (C) 1994-1997, Andrew Cagney + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + */ + + +#ifndef _SIM_EVENTS_C_ +#define _SIM_EVENTS_C_ + +#include "sim-main.h" +#include "sim-assert.h" + +#include + + +/* The event queue maintains a single absolute time using two + variables. + + TIME_OF_EVENT: this holds the time at which the next event is ment + to occure. If no next event it will hold the time of the last + event. + + TIME_FROM_EVENT: The current distance from TIME_OF_EVENT. If an + event is pending, this will be positive. If no future event is + pending this will be negative. This variable is decremented once + for each iteration of a clock cycle. + + Initially, the clock is started at time one (0) with TIME_OF_EVENT + == 0 and TIME_FROM_EVENT == 0. + + Clearly there is a bug in that this code assumes that the absolute + time counter will never become greater than 2^62. + + To avoid the need to use 64bit arithmetic, the event queue always + contains at least one event scheduled every 16 000 ticks. This + limits the time from event counter to values less than + 16 000. */ + + +#if !defined (SIM_EVENTS_POLL_RATE) +#define SIM_EVENTS_POLL_RATE 0x4000 +#endif + + +#define _ETRACE sd + +#undef ETRACE +#define ETRACE(ARGS) \ +do \ + { \ + if (WITH_TRACE) \ + { \ + if (sd->events.trace) \ + { \ + const char *file; \ + SIM_FILTER_PATH(file, __FILE__); \ + sim_io_printf (sd, "%s:%d: ", file, __LINE__); \ + sim_io_printf ARGS; \ + } \ + } \ + } \ +while (0) + + +STATIC_INLINE_SIM_EVENTS\ +(void) +sim_events_poll (void *data) +{ + /* just re-schedule in 1000 million ticks time */ + SIM_DESC sd = data; + sim_events_schedule(sd, SIM_EVENTS_POLL_RATE, sim_events_poll, sd); + sim_io_poll_quit (sd); +} + + +INLINE_SIM_EVENTS\ +(void) +sim_events_init(SIM_DESC sd) +{ + sim_events *events = &sd->events; + sim_event *event; + + /* drain the interrupt queue */ + { +#if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK) + sigset_t old_mask; + sigset_t new_mask; + sigfillset(&new_mask); + /*-LOCK-*/ sigprocmask(SIG_SETMASK, &new_mask, &old_mask); +#endif + event = events->held; + while (event != NULL) { + sim_event *dead = event; + event = event->next; + zfree(dead); + } + events->held = NULL; + events->held_end = &events->held; +#if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK) + /*-UNLOCK-*/ sigprocmask(SIG_SETMASK, &old_mask, NULL); +#endif + } + + /* drain the normal queue */ + event = events->queue; + while (event != NULL) { + sim_event *dead = event; + event = event->next; + zfree(dead); + } + events->queue = NULL; + + /* wind time back to zero */ + events->processing = 0; + events->time_of_event = 0; + events->time_from_event = 0; + + /* schedule our initial counter event */ + sim_events_schedule(sd, 0, sim_events_poll, sd); + + /* from now on, except when the large-int event is being processed + the event queue is non empty */ + SIM_ASSERT(events->queue != NULL); +} + +INLINE_SIM_EVENTS\ +(signed64) +sim_events_time(SIM_DESC sd) +{ + sim_events *events = &sd->events; + return events->time_of_event - events->time_from_event; +} + +STATIC_INLINE_SIM_EVENTS\ +(void) +update_time_from_event(SIM_DESC sd) +{ + sim_events *events = &sd->events; + signed64 current_time = sim_events_time(sd); + if (events->queue != NULL) { + events->time_from_event = (events->queue->time_of_event - current_time); + events->time_of_event = events->queue->time_of_event; + } + else { + events->time_of_event = current_time - 1; + events->time_from_event = -1; + } + SIM_ASSERT(current_time == sim_events_time (sd)); + SIM_ASSERT((events->time_from_event >= 0) == (events->queue != NULL)); +} + +STATIC_INLINE_SIM_EVENTS\ +(void) +insert_sim_event(SIM_DESC sd, + sim_event *new_event, + signed64 delta) +{ + sim_events *events = &sd->events; + sim_event *curr; + sim_event **prev; + signed64 time_of_event; + + if (delta < 0) + engine_error (sd, "what is past is past!\n"); + + /* compute when the event should occure */ + time_of_event = sim_events_time(sd) + delta; + + /* find the queue insertion point - things are time ordered */ + prev = &events->queue; + curr = events->queue; + while (curr != NULL && time_of_event >= curr->time_of_event) { + SIM_ASSERT(curr->next == NULL + || curr->time_of_event <= curr->next->time_of_event); + prev = &curr->next; + curr = curr->next; + } + SIM_ASSERT(curr == NULL || time_of_event < curr->time_of_event); + + /* insert it */ + new_event->next = curr; + *prev = new_event; + new_event->time_of_event = time_of_event; + + /* adjust the time until the first event */ + update_time_from_event(sd); +} + +INLINE_SIM_EVENTS\ +(sim_event *) +sim_events_schedule(SIM_DESC sd, + signed64 delta_time, + sim_event_handler *handler, + void *data) +{ + sim_event *new_event = ZALLOC(sim_event); + new_event->data = data; + new_event->handler = handler; + insert_sim_event(sd, new_event, delta_time); + ETRACE((_ETRACE, + "event scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n", + (long)sim_events_time(sd), + (long)new_event, + (long)new_event->time_of_event, + (long)new_event->handler, + (long)new_event->data)); + return new_event; +} + + +INLINE_SIM_EVENTS\ +(sim_event *) +sim_events_schedule_after_signal(SIM_DESC sd, + signed64 delta_time, + sim_event_handler *handler, + void *data) +{ + sim_events *events = &sd->events; + sim_event *new_event = ZALLOC(sim_event); + + new_event->data = data; + new_event->handler = handler; + new_event->time_of_event = delta_time; /* work it out later */ + new_event->next = NULL; + + { +#if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK) + sigset_t old_mask; + sigset_t new_mask; + sigfillset(&new_mask); + /*-LOCK-*/ sigprocmask(SIG_SETMASK, &new_mask, &old_mask); +#endif + if (events->held == NULL) { + events->held = new_event; + } + else { + *events->held_end = new_event; + } + events->held_end = &new_event->next; +#if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK) + /*-UNLOCK-*/ sigprocmask(SIG_SETMASK, &old_mask, NULL); +#endif + } + + ETRACE((_ETRACE, + "event scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n", + (long)sim_events_time(sd), + (long)new_event, + (long)new_event->time_of_event, + (long)new_event->handler, + (long)new_event->data)); + + return new_event; +} + + +INLINE_SIM_EVENTS\ +(void) +sim_events_deschedule(SIM_DESC sd, + sim_event *event_to_remove) +{ + sim_events *events = &sd->events; + sim_event *to_remove = (sim_event*)event_to_remove; + SIM_ASSERT((events->time_from_event >= 0) == (events->queue != NULL)); + if (event_to_remove != NULL) { + sim_event *current; + sim_event **ptr_to_current; + for (ptr_to_current = &events->queue, current = *ptr_to_current; + current != NULL && current != to_remove; + ptr_to_current = ¤t->next, current = *ptr_to_current); + if (current == to_remove) { + *ptr_to_current = current->next; + ETRACE((_ETRACE, + "event descheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n", + (long)sim_events_time(sd), + (long)event_to_remove, + (long)current->time_of_event, + (long)current->handler, + (long)current->data)); + zfree(current); + update_time_from_event(sd); + } + else { + ETRACE((_ETRACE, + "event descheduled at %ld - tag 0x%lx - not found\n", + (long)sim_events_time(sd), + (long)event_to_remove)); + } + } + SIM_ASSERT((events->time_from_event >= 0) == (events->queue != NULL)); +} + + + + +INLINE_SIM_EVENTS\ +(int) +sim_events_tick(SIM_DESC sd) +{ + sim_events *events = &sd->events; + + /* we should only be here when the previous tick has been fully + processed */ + SIM_ASSERT(!events->processing && events->queue != NULL); + + /* Advance the time but *only* if there is nothing to process */ + if (events->time_from_event == 0) + return 1; + else if (events->held != NULL) + return 1; + else { + events->time_from_event -= 1; + return 0; + } +} + + + +INLINE_SIM_EVENTS\ +(void) +sim_events_process(SIM_DESC sd) +{ + sim_events *events = &sd->events; + signed64 event_time = sim_events_time(sd); + + /* something to do */ + SIM_ASSERT(events->time_from_event == 0 || events->held != NULL); + SIM_ASSERT(events->queue != NULL); + + /* move any events that were queued by any signal handlers onto the + real event queue. */ + if (events->held != NULL) { + sim_event *held_events; + sim_event *curr_event; + +#if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK) + /*-LOCK-*/ + sigset_t old_mask; + sigset_t new_mask; + sigfillset(&new_mask); + sigprocmask(SIG_SETMASK, &new_mask, &old_mask); +#endif + + held_events = events->held; + events->held = NULL; + events->held_end = &events->held; + +#if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK) + /*-UNLOCK-*/ + sigprocmask(SIG_SETMASK, &old_mask, NULL); +#endif + + do { + curr_event = held_events; + held_events = curr_event->next; + insert_sim_event(sd, curr_event, curr_event->time_of_event); + } while (held_events != NULL); + } + + /* consume all events for this or earlier times. Be careful to + allow a new event to appear under our feet */ + events->processing = 1; + while (events->queue->time_of_event <= event_time) { + sim_event *to_do = events->queue; + sim_event_handler *handler = to_do->handler; + void *data = to_do->data; + events->queue = to_do->next; + ETRACE((_ETRACE, + "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx\n", + (long)event_time, + (long)to_do, + (long)handler, + (long)data)); + zfree (to_do); + handler (data); + } + events->processing = 0; + + /* re-caculate time for new events - advance the time */ + update_time_from_event(sd); + SIM_ASSERT(events->time_from_event > 0 && events->queue != NULL); + events->time_from_event -= 1; +} + +#endif diff --git a/sim/d10v/ChangeLog b/sim/d10v/ChangeLog index 1f007c2..d06d38f 100644 --- a/sim/d10v/ChangeLog +++ b/sim/d10v/ChangeLog @@ -1,3 +1,7 @@ +Fri Apr 18 13:39:01 1997 Andrew Cagney + + * interp.c (sim_stop): New function. + Thu Apr 17 02:42:00 1997 Doug Evans * Makefile.in (SIM_OBJS): Add sim-load.o. diff --git a/sim/d10v/interp.c b/sim/d10v/interp.c index 0eaf8e6..5eed234 100644 --- a/sim/d10v/interp.c +++ b/sim/d10v/interp.c @@ -616,6 +616,15 @@ sim_ctrl_c() } +int +sim_stop (sd) + SIM_DESC sd; +{ + stop_simulator = 1; + return 1; +} + + /* Run (or resume) the program. */ void sim_resume (sd, step, siggnal) diff --git a/sim/h8300/ChangeLog b/sim/h8300/ChangeLog index 1c0f27d..6686951 100644 --- a/sim/h8300/ChangeLog +++ b/sim/h8300/ChangeLog @@ -1,3 +1,8 @@ +Fri Apr 18 14:30:09 1997 Andrew Cagney + + * compile.c (sim_resume): Use poll_quit callback. + (sim_stop): New function. + Thu Apr 17 03:06:39 1997 Doug Evans * Makefile.in (SIM_OBJS): Add sim-load.o. diff --git a/sim/mn10300/ChangeLog b/sim/mn10300/ChangeLog index 825c2e5..4322b92 100644 --- a/sim/mn10300/ChangeLog +++ b/sim/mn10300/ChangeLog @@ -1,3 +1,7 @@ +Fri Apr 18 14:04:04 1997 Andrew Cagney + + * interp.c (sim_stop): Add stub function. + Thu Apr 17 03:26:59 1997 Doug Evans * Makefile.in (SIM_OBJS): Add sim-load.o. diff --git a/sim/ppc/ChangeLog b/sim/ppc/ChangeLog index 9c35194..49b0aa2 100644 --- a/sim/ppc/ChangeLog +++ b/sim/ppc/ChangeLog @@ -1,3 +1,26 @@ +Fri Apr 18 17:03:09 1997 Andrew Cagney + + * sim_calls.c (sim_stop_reason): Simplify. Was running implies + stopped/SIGINT. Exit implies a status code. + + * psim.c (cntrl_c_simulation): From main.c. Event function that + halts the simulator. + (psim_stop): New. Asynchronously schedule a stop simulator event. + (psim_run_until_stop): Delete. Made redundant by psim_stop. + + * main.c (cntrl_c): Update. + (cntrl_c_simulation): Moved to psim.c. + + * sim_calls.c (sim_stop): New function. Use psim_stop which + schedules a stop event. + (sim_resume): Drop SIGINT handler, now in gdb/main.c. + (sim_resume): Use psim_run as stop variable no longer needed. + +Fri Apr 18 17:03:08 1997 Andrew Cagney + + * psim.c (psim_options): Handle -E option correctly. + (psim_usage): Document. + Thu Apr 17 03:28:03 1997 Doug Evans * psim.c (psim_options): Ignore -E option (sets endianness). diff --git a/sim/ppc/main.c b/sim/ppc/main.c index 454efed..091486b 100644 --- a/sim/ppc/main.c +++ b/sim/ppc/main.c @@ -23,9 +23,12 @@ #include #include +#include + #include "psim.h" #include "options.h" #include "device.h" /* FIXME: psim should provide the interface */ +#include "events.h" /* FIXME: psim should provide the interface */ #ifdef HAVE_STDLIB_H #include @@ -149,6 +152,7 @@ sim_io_read_stdin(char *buf, return sim_io_eof; break; case DONT_USE_STDIO: +#if defined(O_NDELAY) && defined(F_GETFL) && defined(F_SETFL) { /* check for input */ int flags; @@ -189,6 +193,7 @@ sim_io_read_stdin(char *buf, return result; } break; +#endif default: error("sim_io_read_stdin: invalid switch\n"); break; @@ -228,6 +233,15 @@ zfree(void *chunk) free(chunk); } +/* When a CNTRL-C occures, queue an event to shut down the simulation */ + +static RETSIGTYPE +cntrl_c(int sig) +{ + psim_stop (simulation); +} + + int main(int argc, char **argv) { @@ -264,7 +278,12 @@ main(int argc, char **argv) psim_init(simulation); psim_stack(simulation, argv, environ); - psim_run(simulation); + { + RETSIGTYPE (*prev) (); + prev = signal(SIGINT, cntrl_c); + psim_run(simulation); + signal(SIGINT, prev); + } /* any final clean up */ if (ppc_trace[trace_print_info]) diff --git a/sim/sh/ChangeLog b/sim/sh/ChangeLog index 91bcaef..91dfd34 100644 --- a/sim/sh/ChangeLog +++ b/sim/sh/ChangeLog @@ -1,3 +1,8 @@ +Fri Apr 18 14:14:49 1997 Andrew Cagney + + * interp.c (sim_stop): New function. + (sim_resume): Use poll_quit for polling. + Thu Apr 17 03:32:04 1997 Doug Evans * Makefile.in (SIM_OBJS): Add sim-load.o. diff --git a/sim/sh/interp.c b/sim/sh/interp.c index f50c76b..98f10e8 100644 --- a/sim/sh/interp.c +++ b/sim/sh/interp.c @@ -883,6 +883,14 @@ gotcall (from, to) #define MMASKB ((saved_state.asregs.msize -1) & ~0) +int +sim_stop (sd) + SIM_DESC sd; +{ + saved_state.asregs.exception = SIGINT; + return 1; +} + void sim_resume (sd, step, siggnal) SIM_DESC sd; @@ -896,9 +904,7 @@ sim_resume (sd, step, siggnal) register int prevlock; register int thislock; register unsigned int doprofile; -#if defined(__GO32__) || defined(WIN32) register int pollcount = 0; -#endif register int little_endian = little_endian_p; int tick_start = get_now (); @@ -959,32 +965,16 @@ sim_resume (sd, step, siggnal) pc += 2; -#ifdef __GO32__ pollcount++; if (pollcount > 1000) { pollcount = 0; - if (kbhit()) { - int k = getkey(); - if (k == 1) - saved_state.asregs.exception = SIGINT; - - } - } -#endif - /* FIXME: Testing for INSIDE_SIMULATOR is wrong. - Only one copy of interp.o is built. */ -#if defined (WIN32) && !defined(INSIDE_SIMULATOR) - pollcount++; - if (pollcount > 1000) - { - pollcount = 0; - if (win32pollquit()) + if ((*callback->poll_quit) != NULL + && (*callback->poll_quit) (sd)) { - control_c(); - } + sim_stop (sd); + } } -#endif #ifndef ACE_FAST prevlock = thislock; diff --git a/sim/v850/ChangeLog b/sim/v850/ChangeLog index 72d507d..e418ae6 100644 --- a/sim/v850/ChangeLog +++ b/sim/v850/ChangeLog @@ -1,3 +1,7 @@ +Fri Apr 18 14:17:12 1997 Andrew Cagney + + * interp.c (sim_stop): Stub function. + Thu Apr 17 03:53:18 1997 Doug Evans * Makefile.in (SIM_OBJS): Add sim-load.o. diff --git a/sim/v850/interp.c b/sim/v850/interp.c index d1aa8eb..da1cfd8 100644 --- a/sim/v850/interp.c +++ b/sim/v850/interp.c @@ -568,6 +568,13 @@ time_t start_time; static void do_interrupt PARAMS ((enum interrupt_type)); +int +sim_stop (sd) + SIM_DESC sd; +{ + return 0; +} + void sim_resume (sd, step, siggnal) SIM_DESC sd; -- cgit v1.1