*/
-#ifndef _SIM_EVENTS_H_
-#define _SIM_EVENTS_H_
+#ifndef SIM_EVENTS_H
+#define SIM_EVENTS_H
/* Notes:
illustrated above, the event queue should be processed before the
first instruction. That instruction being executed during tick 1.
- The event queue is processed using:
+ The simulator main loop may take a form similar to:
- if (sim_events_tick (sd)) {
- sim_events_process (sd);
- }
+ if (halt-/restart-setjmp)
+ {
- */
-
+ .... // Determine who should go next
+ last-cpu-nr = get-last-cpu-nr (sd);
+ next-cpu-nr = get-next-cpu-nr (sd);
+ events-were-last? = (last-cpu-nr >= nr-cpus);
+ events-were-next? = (next-cpu-nr >= nr-cpus);
-typedef void sim_event_handler(void *data);
+ .... // process any outstanding events
+ sim_events_preprocess (sd, events-were-last?, events-were-next?);
+ if (events-were-next)
+ next-cpu-nr = 0;
+
+ .... // prime main loop
+
+ while (1)
+ {
+ .... // model one insn of next-cpu-nr .. nr-cpus
+ if (sim_events_tick (sd))
+ sim_events_process (sd);
+ next-cpu-nr = 0
+ }
+ }
+
+ NB. In the above pseudo code it is assumed that any cpu-nr >=
+ nr-cpus is a marker for the event queue. */
+
+
+typedef void sim_event_handler(SIM_DESC sd, void *data);
typedef struct _sim_event sim_event;
-struct _sim_event {
- void *data;
- sim_event_handler *handler;
- signed64 time_of_event;
- sim_event *next;
-};
typedef struct _sim_events sim_events;
struct _sim_events {
- int processing;
+ int nr_ticks_to_process;
sim_event *queue;
- sim_event *volatile held;
- sim_event *volatile *volatile held_end;
+ sim_event *watchpoints;
+ sim_event *watchedpoints;
+ sim_event *free_list;
+ /* flag additional work needed */
+ volatile int work_pending;
+ /* the asynchronous event queue */
+#ifndef MAX_NR_SIGNAL_SIM_EVENTS
+#define MAX_NR_SIGNAL_SIM_EVENTS 2
+#endif
+ sim_event *held;
+ volatile int nr_held;
+ /* timekeeping */
+ unsigned long elapsed_wallclock;
+ SIM_ELAPSED_TIME resume_wallclock;
signed64 time_of_event;
int time_from_event;
- void *path_to_halt_or_restart;
int trace;
};
-/* Initialization */
+/* Install the "events" module. */
-INLINE_SIM_EVENTS\
-(void) sim_events_init
-(SIM_DESC sd);
+extern SIM_RC sim_events_install (SIM_DESC sd);
-/* Set Tracing Level */
+/* Schedule an event DELTA_TIME ticks into the future */
-INLINE_SIM_EVENTS\
-(void) sim_events_set_trace
+extern sim_event *sim_events_schedule
(SIM_DESC sd,
- int level);
-
+ signed64 delta_time,
+ sim_event_handler *handler,
+ void *data);
-/* Schedule an event DELTA_TIME ticks into the future */
+extern sim_event *sim_events_schedule_tracef
+(SIM_DESC sd,
+ signed64 delta_time,
+ sim_event_handler *handler,
+ void *data,
+ const char *fmt,
+ ...) __attribute__ ((format (printf, 5, 6)));
-INLINE_SIM_EVENTS\
-(sim_event *) sim_events_schedule
+extern sim_event *sim_events_schedule_vtracef
(SIM_DESC sd,
signed64 delta_time,
sim_event_handler *handler,
- void *data);
+ void *data,
+ const char *fmt,
+ va_list ap);
-INLINE_SIM_EVENTS\
-(sim_event *) sim_events_schedule_after_signal
+
+extern void sim_events_schedule_after_signal
(SIM_DESC sd,
signed64 delta_time,
sim_event_handler *handler,
void *data);
+/* NB: signal level events can't have trace strings as malloc isn't
+ available */
-/* Schedule an event WALLCLOCK milli-seconds from the start of the
- simulation. The exact interpretation of wallclock is host
- dependant. */
-INLINE_SIM_EVENTS\
-(void) sim_events_wallclock_schedule
+
+/* Schedule an event milli-seconds from NOW. The exact interpretation
+ of wallclock is host dependant. */
+
+extern sim_event *sim_events_watch_clock
(SIM_DESC sd,
- signed64 wallclock_ms_time,
+ unsigned delta_ms_time,
sim_event_handler *handler,
void *data);
-#if 0
-/* Schedule an event when the value at ADDR lies between LB..UB */
-
-typedef enum {
- /* value host byte ordered */
- watch_host_1,
- watch_host_2,
- watch_host_4,
- watch_host_8,
- /* value target byte ordered */
- watch_targ_1,
- watch_targ_2,
- watch_targ_4,
- watch_targ_8,
- /* value big-endian */
- watch_bend_1,
- watch_bend_2,
- watch_bend_4,
- watch_bend_8,
- /* value little-endian */
- watch_lend_1,
- watch_lend_2,
- watch_lend_4,
- watch_lend_8,
-} sim_watchpoint;
+/* Schedule an event when the test (IS_WITHIN == (VAL >= LB && VAL <=
+ UB)) of the NR_BYTES value at HOST_ADDR with BYTE_ORDER endian is
+ true.
-INLINE_SIM_EVENTS\
-(void) sim_events_watchpoint_schedule
+ HOST_ADDR: pointer into the host address space.
+ BYTE_ORDER: 0 - host endian; BIG_ENDIAN; LITTLE_ENDIAN */
+
+extern sim_event *sim_events_watch_sim
(SIM_DESC sd,
- sim_watchpoint type,
- void *addr,
+ void *host_addr,
+ int nr_bytes,
+ int byte_order,
+ int is_within,
unsigned64 lb,
unsigned64 ub,
sim_event_handler *handler,
void *data);
-#endif
-#if 0
-/* Schedule an event when the value in CORE lies between LB..UB */
+/* Schedule an event when the test (IS_WITHIN == (VAL >= LB && VAL <=
+ UB)) of the NR_BYTES value at CORE_ADDR in BYTE_ORDER endian is
+ true.
-INLINE_SIM_EVENTS\
-(void) sim_events_watchcore_schedule
+ CORE_ADDR/MAP: pointer into the target address space.
+ BYTE_ORDER: 0 - current target endian; BIG_ENDIAN; LITTLE_ENDIAN */
+
+extern sim_event *sim_events_watch_core
(SIM_DESC sd,
- sim_watchpoint type,
- address_word addr,
- sim_core_maps map,
+ address_word core_addr,
+ unsigned map,
+ int nr_bytes,
+ int byte_order,
+ int is_within,
unsigned64 lb,
unsigned64 ub,
sim_event_handler *handler,
void *data);
-#endif
-
/* Deschedule the specified event */
-INLINE_SIM_EVENTS\
-(void) sim_events_deschedule
+extern void sim_events_deschedule
(SIM_DESC sd,
sim_event *event_to_remove);
+/* Prepare for main simulator loop. Ensure that the next thing to do
+ is not event processing.
+
+ If the simulator halted part way through event processing then both
+ EVENTS_WERE_LAST and EVENTS_WERE_NEXT shall be true.
+
+ If the simulator halted after processing the last cpu, then only
+ EVENTS_WERE_NEXT shall be true. */
+
+INLINE_SIM_EVENTS\
+(void) sim_events_preprocess
+(SIM_DESC sd,
+ int events_were_last,
+ int events_were_next);
+
+
+/* Progress time.
+
+ Separated into two parts so that the main loop can save its context
+ before the event queue is processed. When sim_events_tick*()
+ returns true, any simulation context should be saved and
+ sim_events_process() called.
-/* progress time. Broken into two parts so that if something is
- pending, the caller has a chance to save any cached state */
+ SIM_EVENTS_TICK advances the clock by 1 cycle.
+
+ SIM_EVENTS_TICKN advances the clock by N cycles (1..MAXINT). */
INLINE_SIM_EVENTS\
(int) sim_events_tick
(SIM_DESC sd);
+INLINE_SIM_EVENTS\
+(int) sim_events_tickn
+(SIM_DESC sd,
+ int n);
+
INLINE_SIM_EVENTS\
(void) sim_events_process
(SIM_DESC sd);
-/* local concept of time */
+/* Advance the clock by an additional SLIP cycles at the next call to
+ sim_events_tick*(). For multiple calls, the effect is
+ accumulative. */
+
+INLINE_SIM_EVENTS\
+(void) sim_events_slip
+(SIM_DESC sd,
+ int slip);
+
+
+/* Progress time such that an event shall occure upon the next call to
+ sim_events tick */
+
+#if 0
+INLINE_SIM_EVENTS\
+(void) sim_events_timewarp
+(SIM_DESC sd);
+#endif
+
+
+/* local concept of elapsed target time */
INLINE_SIM_EVENTS\
(signed64) sim_events_time
(SIM_DESC sd);
+/* local concept of elapsed host time (milliseconds) */
+
+INLINE_SIM_EVENTS\
+(unsigned long) sim_events_elapsed_time
+(SIM_DESC sd);
+
#endif
projects / deliverable / binutils-gdb.git / blobdiff