1 /* This file is part of the program psim.
3 Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 #ifndef _SIM_EVENTS_C_
23 #define _SIM_EVENTS_C_
26 #include "sim-assert.h"
40 #include <signal.h> /* For SIGPROCMASK et al. */
45 /* core - target byte order */
50 /* core - big-endian */
55 /* core - little-endian */
61 /* sim - host byte order */
66 /* sim - big-endian */
71 /* sim - little-endian */
82 } sim_event_watchpoints
;
86 sim_event_watchpoints watching
;
88 sim_event_handler
*handler
;
90 signed64 time_of_event
;
91 /* watch wallclock event */
93 /* watch core address */
94 address_word core_addr
;
98 /* watch core/sim range */
99 int is_within
; /* 0/1 */
104 /* trace info (if any) */
111 /* The event queue maintains a single absolute time using two
114 TIME_OF_EVENT: this holds the time at which the next event is ment
115 to occur. If no next event it will hold the time of the last
118 TIME_FROM_EVENT: The current distance from TIME_OF_EVENT. A value
119 <= 0 (except when poll-event is being processed) indicates that
120 event processing is due. This variable is decremented once for
121 each iteration of a clock cycle.
123 Initially, the clock is started at time one (0) with TIME_OF_EVENT
124 == 0 and TIME_FROM_EVENT == 0 and with NR_TICKS_TO_PROCESS == 1.
126 Clearly there is a bug in that this code assumes that the absolute
127 time counter will never become greater than 2^62.
129 To avoid the need to use 64bit arithmetic, the event queue always
130 contains at least one event scheduled every 16 000 ticks. This
131 limits the time from event counter to values less than
135 #if !defined (SIM_EVENTS_POLL_RATE)
136 #define SIM_EVENTS_POLL_RATE 0x1000
140 #define _ETRACE sd, NULL
143 #define ETRACE_P (WITH_TRACE && STATE_EVENTS (sd)->trace)
146 #define ETRACE(ARGS) \
151 if (STRACE_DEBUG_P (sd)) \
154 SIM_FILTER_PATH (file, __FILE__); \
155 trace_printf (sd, NULL, "%s:%d: ", file, __LINE__); \
163 /* event queue iterator - don't iterate over the held queue. */
165 #if EXTERN_SIM_EVENTS_P
167 next_event_queue (SIM_DESC sd
,
171 return &STATE_EVENTS (sd
)->queue
;
172 else if (queue
== &STATE_EVENTS (sd
)->queue
)
173 return &STATE_EVENTS (sd
)->watchpoints
;
174 else if (queue
== &STATE_EVENTS (sd
)->watchpoints
)
175 return &STATE_EVENTS (sd
)->watchedpoints
;
176 else if (queue
== &STATE_EVENTS (sd
)->watchedpoints
)
179 sim_io_error (sd
, "next_event_queue - bad queue");
185 STATIC_INLINE_SIM_EVENTS\
187 sim_events_poll (SIM_DESC sd
,
190 /* just re-schedule in 1000 million ticks time */
191 sim_events_schedule (sd
, SIM_EVENTS_POLL_RATE
, sim_events_poll
, sd
);
192 sim_io_poll_quit (sd
);
196 /* "events" module install handler.
197 This is called via sim_module_install to install the "events" subsystem
198 into the simulator. */
200 #if EXTERN_SIM_EVENTS_P
201 STATIC_SIM_EVENTS (MODULE_UNINSTALL_FN
) sim_events_uninstall
;
202 STATIC_SIM_EVENTS (MODULE_INIT_FN
) sim_events_init
;
203 STATIC_SIM_EVENTS (MODULE_RESUME_FN
) sim_events_resume
;
204 STATIC_SIM_EVENTS (MODULE_SUSPEND_FN
) sim_events_suspend
;
207 #if EXTERN_SIM_EVENTS_P
209 sim_events_install (SIM_DESC sd
)
211 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
212 sim_module_add_uninstall_fn (sd
, sim_events_uninstall
);
213 sim_module_add_init_fn (sd
, sim_events_init
);
214 sim_module_add_resume_fn (sd
, sim_events_resume
);
215 sim_module_add_suspend_fn (sd
, sim_events_suspend
);
221 /* Suspend/resume the event queue manager when the simulator is not
224 #if EXTERN_SIM_EVENTS_P
226 sim_events_resume (SIM_DESC sd
)
228 sim_events
*events
= STATE_EVENTS (sd
);
229 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
230 SIM_ASSERT (events
->resume_wallclock
== 0);
231 events
->resume_wallclock
= sim_elapsed_time_get ();
236 #if EXTERN_SIM_EVENTS_P
238 sim_events_suspend (SIM_DESC sd
)
240 sim_events
*events
= STATE_EVENTS (sd
);
241 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
242 SIM_ASSERT (events
->resume_wallclock
!= 0);
243 events
->elapsed_wallclock
+= sim_elapsed_time_since (events
->resume_wallclock
);
244 events
->resume_wallclock
= 0;
250 /* Uninstall the "events" subsystem from the simulator. */
252 #if EXTERN_SIM_EVENTS_P
254 sim_events_uninstall (SIM_DESC sd
)
256 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
257 /* FIXME: free buffers, etc. */
264 #if EXTERN_SIM_EVENTS_P
266 sim_events_zalloc (SIM_DESC sd
)
268 sim_events
*events
= STATE_EVENTS (sd
);
269 sim_event
*new = events
->free_list
;
272 events
->free_list
= new->next
;
273 memset (new, 0, sizeof (*new));
277 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
281 sigfillset(&new_mask
);
282 sigprocmask (SIG_SETMASK
, &new_mask
, &old_mask
);
284 new = ZALLOC (sim_event
);
285 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
287 sigprocmask (SIG_SETMASK
, &old_mask
, NULL
);
294 STATIC_INLINE_SIM_EVENTS\
296 sim_events_free (SIM_DESC sd
,
299 sim_events
*events
= STATE_EVENTS (sd
);
300 dead
->next
= events
->free_list
;
301 events
->free_list
= dead
;
302 if (dead
->trace
!= NULL
)
304 free (dead
->trace
); /* NB: asprintf returns a `free' buf */
310 /* Initialize the simulator event manager */
312 #if EXTERN_SIM_EVENTS_P
314 sim_events_init (SIM_DESC sd
)
316 sim_events
*events
= STATE_EVENTS (sd
);
318 /* drain the interrupt queue */
320 if (events
->held
== NULL
)
321 events
->held
= NZALLOC (sim_event
, MAX_NR_SIGNAL_SIM_EVENTS
);
323 /* drain the normal queues */
325 sim_event
**queue
= NULL
;
326 while ((queue
= next_event_queue (sd
, queue
)) != NULL
)
328 if (queue
== NULL
) break;
329 while (*queue
!= NULL
)
331 sim_event
*dead
= *queue
;
333 sim_events_free (sd
, dead
);
339 /* wind time back to zero */
340 events
->nr_ticks_to_process
= 1; /* start by doing queue */
341 events
->time_of_event
= 0;
342 events
->time_from_event
= 0;
343 events
->elapsed_wallclock
= 0;
344 events
->resume_wallclock
= 0;
346 /* schedule our initial counter event */
347 sim_events_schedule (sd
, 0, sim_events_poll
, sd
);
349 /* from now on, except when the large-int event is being processed
350 the event queue is non empty */
351 SIM_ASSERT (events
->queue
!= NULL
);
360 sim_events_time (SIM_DESC sd
)
362 sim_events
*events
= STATE_EVENTS (sd
);
363 return (events
->time_of_event
- events
->time_from_event
);
369 sim_events_elapsed_time (SIM_DESC sd
)
371 unsigned long elapsed
= STATE_EVENTS (sd
)->elapsed_wallclock
;
373 /* Are we being called inside sim_resume?
374 (Is there a simulation in progress?) */
375 if (STATE_EVENTS (sd
)->resume_wallclock
!= 0)
376 elapsed
+= sim_elapsed_time_since (STATE_EVENTS (sd
)->resume_wallclock
);
382 /* Returns the time that remains before the event is raised. */
385 sim_events_remain_time (SIM_DESC sd
, sim_event
*event
)
390 return (event
->time_of_event
- sim_events_time (sd
));
395 STATIC_INLINE_SIM_EVENTS\
397 update_time_from_event (SIM_DESC sd
)
399 sim_events
*events
= STATE_EVENTS (sd
);
400 signed64 current_time
= sim_events_time (sd
);
401 if (events
->queue
!= NULL
)
403 events
->time_of_event
= events
->queue
->time_of_event
;
404 events
->time_from_event
= (events
->queue
->time_of_event
- current_time
);
408 events
->time_of_event
= current_time
- 1;
409 events
->time_from_event
= -1;
415 for (event
= events
->queue
, i
= 0;
417 event
= event
->next
, i
++)
420 "event time-from-event - time %ld, delta %ld - event %d, tag 0x%lx, time %ld, handler 0x%lx, data 0x%lx%s%s\n",
422 (long)events
->time_from_event
,
425 (long)event
->time_of_event
,
426 (long)event
->handler
,
428 (event
->trace
!= NULL
) ? ", " : "",
429 (event
->trace
!= NULL
) ? event
->trace
: ""));
432 SIM_ASSERT (current_time
== sim_events_time (sd
));
436 #if EXTERN_SIM_EVENTS_P
438 insert_sim_event (SIM_DESC sd
,
439 sim_event
*new_event
,
442 sim_events
*events
= STATE_EVENTS (sd
);
445 signed64 time_of_event
;
448 sim_io_error (sd
, "what is past is past!\n");
450 /* compute when the event should occur */
451 time_of_event
= sim_events_time (sd
) + delta
;
453 /* find the queue insertion point - things are time ordered */
454 prev
= &events
->queue
;
455 curr
= events
->queue
;
456 while (curr
!= NULL
&& time_of_event
>= curr
->time_of_event
)
458 SIM_ASSERT (curr
->next
== NULL
459 || curr
->time_of_event
<= curr
->next
->time_of_event
);
463 SIM_ASSERT (curr
== NULL
|| time_of_event
< curr
->time_of_event
);
466 new_event
->next
= curr
;
468 new_event
->time_of_event
= time_of_event
;
470 /* adjust the time until the first event */
471 update_time_from_event (sd
);
476 #if EXTERN_SIM_EVENTS_P
478 sim_events_schedule (SIM_DESC sd
,
480 sim_event_handler
*handler
,
484 return sim_events_schedule_vtracef (sd
, delta_time
, handler
, data
,
490 #if EXTERN_SIM_EVENTS_P
492 sim_events_schedule_tracef (SIM_DESC sd
,
494 sim_event_handler
*handler
,
499 sim_event
*new_event
;
502 new_event
= sim_events_schedule_vtracef (sd
, delta_time
, handler
, data
, fmt
, ap
);
509 #if EXTERN_SIM_EVENTS_P
511 sim_events_schedule_vtracef (SIM_DESC sd
,
513 sim_event_handler
*handler
,
518 sim_event
*new_event
= sim_events_zalloc (sd
);
519 new_event
->data
= data
;
520 new_event
->handler
= handler
;
521 new_event
->watching
= watch_timer
;
522 if (fmt
== NULL
|| !ETRACE_P
|| vasprintf (&new_event
->trace
, fmt
, ap
) < 0)
523 new_event
->trace
= NULL
;
524 insert_sim_event(sd
, new_event
, delta_time
);
526 "event scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx%s%s\n",
527 (long)sim_events_time(sd
),
529 (long)new_event
->time_of_event
,
530 (long)new_event
->handler
,
531 (long)new_event
->data
,
532 (new_event
->trace
!= NULL
) ? ", " : "",
533 (new_event
->trace
!= NULL
) ? new_event
->trace
: ""));
539 #if EXTERN_SIM_EVENTS_P
541 sim_events_schedule_after_signal (SIM_DESC sd
,
543 sim_event_handler
*handler
,
546 sim_events
*events
= STATE_EVENTS (sd
);
547 sim_event
*new_event
;
548 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
552 sigfillset(&new_mask
);
553 sigprocmask (SIG_SETMASK
, &new_mask
, &old_mask
);
556 /* allocate an event entry from the signal buffer */
557 new_event
= &events
->held
[events
->nr_held
];
559 if (events
->nr_held
> MAX_NR_SIGNAL_SIM_EVENTS
)
561 sim_engine_abort (NULL
, NULL
, NULL_CIA
,
562 "sim_events_schedule_after_signal - buffer oveflow");
565 new_event
->data
= data
;
566 new_event
->handler
= handler
;
567 new_event
->time_of_event
= delta_time
; /* work it out later */
568 new_event
->next
= NULL
;
570 events
->work_pending
= 1; /* notify main process */
572 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
574 sigprocmask (SIG_SETMASK
, &old_mask
, NULL
);
578 "signal scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
579 (long)sim_events_time(sd
),
581 (long)new_event
->time_of_event
,
582 (long)new_event
->handler
,
583 (long)new_event
->data
));
588 #if EXTERN_SIM_EVENTS_P
590 sim_events_watch_clock (SIM_DESC sd
,
591 unsigned delta_ms_time
,
592 sim_event_handler
*handler
,
595 sim_events
*events
= STATE_EVENTS (sd
);
596 sim_event
*new_event
= sim_events_zalloc (sd
);
598 new_event
->watching
= watch_clock
;
600 new_event
->data
= data
;
601 new_event
->handler
= handler
;
603 if (events
->resume_wallclock
== 0)
604 new_event
->wallclock
= (events
->elapsed_wallclock
+ delta_ms_time
);
606 new_event
->wallclock
= (events
->elapsed_wallclock
607 + sim_elapsed_time_since (events
->resume_wallclock
)
610 new_event
->next
= events
->watchpoints
;
611 events
->watchpoints
= new_event
;
612 events
->work_pending
= 1;
614 "event watching clock at %ld - tag 0x%lx - wallclock %ld, handler 0x%lx, data 0x%lx\n",
615 (long)sim_events_time (sd
),
617 (long)new_event
->wallclock
,
618 (long)new_event
->handler
,
619 (long)new_event
->data
));
625 #if EXTERN_SIM_EVENTS_P
627 sim_events_watch_sim (SIM_DESC sd
,
634 sim_event_handler
*handler
,
637 sim_events
*events
= STATE_EVENTS (sd
);
638 sim_event
*new_event
= sim_events_zalloc (sd
);
645 case 1: new_event
->watching
= watch_sim_host_1
; break;
646 case 2: new_event
->watching
= watch_sim_host_2
; break;
647 case 4: new_event
->watching
= watch_sim_host_4
; break;
648 case 8: new_event
->watching
= watch_sim_host_8
; break;
649 default: sim_io_error (sd
, "sim_events_watch_sim - invalid nr bytes");
655 case 1: new_event
->watching
= watch_sim_be_1
; break;
656 case 2: new_event
->watching
= watch_sim_be_2
; break;
657 case 4: new_event
->watching
= watch_sim_be_4
; break;
658 case 8: new_event
->watching
= watch_sim_be_8
; break;
659 default: sim_io_error (sd
, "sim_events_watch_sim - invalid nr bytes");
665 case 1: new_event
->watching
= watch_sim_le_1
; break;
666 case 2: new_event
->watching
= watch_sim_le_2
; break;
667 case 4: new_event
->watching
= watch_sim_le_4
; break;
668 case 8: new_event
->watching
= watch_sim_le_8
; break;
669 default: sim_io_error (sd
, "sim_events_watch_sim - invalid nr bytes");
673 sim_io_error (sd
, "sim_events_watch_sim - invalid byte order");
676 new_event
->data
= data
;
677 new_event
->handler
= handler
;
679 new_event
->host_addr
= host_addr
;
681 new_event
->lb64
= lb
;
683 new_event
->ub64
= ub
;
684 new_event
->is_within
= (is_within
!= 0);
686 new_event
->next
= events
->watchpoints
;
687 events
->watchpoints
= new_event
;
688 events
->work_pending
= 1;
690 "event watching host at %ld - tag 0x%lx - host-addr 0x%lx, 0x%lx..0x%lx, handler 0x%lx, data 0x%lx\n",
691 (long)sim_events_time (sd
),
693 (long)new_event
->host_addr
,
696 (long)new_event
->handler
,
697 (long)new_event
->data
));
703 #if EXTERN_SIM_EVENTS_P
705 sim_events_watch_core (SIM_DESC sd
,
706 address_word core_addr
,
713 sim_event_handler
*handler
,
716 sim_events
*events
= STATE_EVENTS (sd
);
717 sim_event
*new_event
= sim_events_zalloc (sd
);
724 case 1: new_event
->watching
= watch_core_targ_1
; break;
725 case 2: new_event
->watching
= watch_core_targ_2
; break;
726 case 4: new_event
->watching
= watch_core_targ_4
; break;
727 case 8: new_event
->watching
= watch_core_targ_8
; break;
728 default: sim_io_error (sd
, "sim_events_watch_core - invalid nr bytes");
734 case 1: new_event
->watching
= watch_core_be_1
; break;
735 case 2: new_event
->watching
= watch_core_be_2
; break;
736 case 4: new_event
->watching
= watch_core_be_4
; break;
737 case 8: new_event
->watching
= watch_core_be_8
; break;
738 default: sim_io_error (sd
, "sim_events_watch_core - invalid nr bytes");
744 case 1: new_event
->watching
= watch_core_le_1
; break;
745 case 2: new_event
->watching
= watch_core_le_2
; break;
746 case 4: new_event
->watching
= watch_core_le_4
; break;
747 case 8: new_event
->watching
= watch_core_le_8
; break;
748 default: sim_io_error (sd
, "sim_events_watch_core - invalid nr bytes");
752 sim_io_error (sd
, "sim_events_watch_core - invalid byte order");
755 new_event
->data
= data
;
756 new_event
->handler
= handler
;
758 new_event
->core_addr
= core_addr
;
759 new_event
->core_map
= core_map
;
761 new_event
->lb64
= lb
;
763 new_event
->ub64
= ub
;
764 new_event
->is_within
= (is_within
!= 0);
766 new_event
->next
= events
->watchpoints
;
767 events
->watchpoints
= new_event
;
768 events
->work_pending
= 1;
770 "event watching host at %ld - tag 0x%lx - host-addr 0x%lx, 0x%lx..0x%lx, handler 0x%lx, data 0x%lx\n",
771 (long)sim_events_time (sd
),
773 (long)new_event
->host_addr
,
776 (long)new_event
->handler
,
777 (long)new_event
->data
));
783 #if EXTERN_SIM_EVENTS_P
785 sim_events_deschedule (SIM_DESC sd
,
786 sim_event
*event_to_remove
)
788 sim_events
*events
= STATE_EVENTS (sd
);
789 sim_event
*to_remove
= (sim_event
*)event_to_remove
;
790 if (event_to_remove
!= NULL
)
792 sim_event
**queue
= NULL
;
793 while ((queue
= next_event_queue (sd
, queue
)) != NULL
)
795 sim_event
**ptr_to_current
;
796 for (ptr_to_current
= queue
;
797 *ptr_to_current
!= NULL
&& *ptr_to_current
!= to_remove
;
798 ptr_to_current
= &(*ptr_to_current
)->next
);
799 if (*ptr_to_current
== to_remove
)
801 sim_event
*dead
= *ptr_to_current
;
802 *ptr_to_current
= dead
->next
;
804 "event/watch descheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx%s%s\n",
805 (long) sim_events_time (sd
),
806 (long) event_to_remove
,
807 (long) dead
->time_of_event
,
808 (long) dead
->handler
,
810 (dead
->trace
!= NULL
) ? ", " : "",
811 (dead
->trace
!= NULL
) ? dead
->trace
: ""));
812 sim_events_free (sd
, dead
);
813 update_time_from_event (sd
);
814 SIM_ASSERT ((events
->time_from_event
>= 0) == (events
->queue
!= NULL
));
820 "event/watch descheduled at %ld - tag 0x%lx - not found\n",
821 (long) sim_events_time (sd
),
822 (long) event_to_remove
));
827 STATIC_INLINE_SIM_EVENTS\
829 sim_watch_valid (SIM_DESC sd
,
832 switch (to_do
->watching
)
835 #define WATCH_CORE(N,OP,EXT) \
837 unsigned_##N word = 0; \
838 int nr_read = sim_core_read_buffer (sd, NULL, to_do->core_map, &word, \
839 to_do->core_addr, sizeof (word)); \
841 ok = (nr_read == sizeof (unsigned_##N) \
842 && (to_do->is_within \
843 == (word >= to_do->lb##EXT \
844 && word <= to_do->ub##EXT)));
846 case watch_core_targ_1
:
848 WATCH_CORE (1, T2H
,);
851 case watch_core_targ_2
:
853 WATCH_CORE (2, T2H
,);
856 case watch_core_targ_4
:
858 WATCH_CORE (4, T2H
,);
861 case watch_core_targ_8
:
863 WATCH_CORE (8, T2H
,64);
867 case watch_core_be_1
:
869 WATCH_CORE (1, BE2H
,);
872 case watch_core_be_2
:
874 WATCH_CORE (2, BE2H
,);
877 case watch_core_be_4
:
879 WATCH_CORE (4, BE2H
,);
882 case watch_core_be_8
:
884 WATCH_CORE (8, BE2H
,64);
888 case watch_core_le_1
:
890 WATCH_CORE (1, LE2H
,);
893 case watch_core_le_2
:
895 WATCH_CORE (2, LE2H
,);
898 case watch_core_le_4
:
900 WATCH_CORE (4, LE2H
,);
903 case watch_core_le_8
:
905 WATCH_CORE (8, LE2H
,64);
910 #define WATCH_SIM(N,OP,EXT) \
912 unsigned_##N word = *(unsigned_##N*)to_do->host_addr; \
914 ok = (to_do->is_within \
915 == (word >= to_do->lb##EXT \
916 && word <= to_do->ub##EXT));
918 case watch_sim_host_1
:
920 WATCH_SIM (1, word
= ,);
923 case watch_sim_host_2
:
925 WATCH_SIM (2, word
= ,);
928 case watch_sim_host_4
:
930 WATCH_SIM (4, word
= ,);
933 case watch_sim_host_8
:
935 WATCH_SIM (8, word
= ,64);
941 WATCH_SIM (1, BE2H
,);
946 WATCH_SIM (2, BE2H
,);
951 WATCH_SIM (4, BE2H
,);
956 WATCH_SIM (8, BE2H
,64);
962 WATCH_SIM (1, LE2H
,);
967 WATCH_SIM (1, LE2H
,);
972 WATCH_SIM (1, LE2H
,);
977 WATCH_SIM (1, LE2H
,64);
982 case watch_clock
: /* wallclock */
984 unsigned long elapsed_time
= sim_events_elapsed_time (sd
);
985 return (elapsed_time
>= to_do
->wallclock
);
989 sim_io_error (sd
, "sim_watch_valid - bad switch");
999 sim_events_tick (SIM_DESC sd
)
1001 sim_events
*events
= STATE_EVENTS (sd
);
1003 /* this should only be called after the previous ticks have been
1006 /* Advance the time but *only* if there is nothing to process */
1007 if (events
->work_pending
1008 || events
->time_from_event
== 0)
1010 events
->nr_ticks_to_process
+= 1;
1015 events
->time_from_event
-= 1;
1023 sim_events_tickn (SIM_DESC sd
,
1026 sim_events
*events
= STATE_EVENTS (sd
);
1029 /* this should only be called after the previous ticks have been
1032 /* Advance the time but *only* if there is nothing to process */
1033 if (events
->work_pending
|| events
->time_from_event
< n
)
1035 events
->nr_ticks_to_process
+= n
;
1040 events
->time_from_event
-= n
;
1048 sim_events_slip (SIM_DESC sd
,
1051 sim_events
*events
= STATE_EVENTS (sd
);
1052 SIM_ASSERT (slip
> 0);
1054 /* Flag a ready event with work_pending instead of number of ticks
1055 to process so that the time continues to be correct */
1056 if (events
->time_from_event
< slip
)
1058 events
->work_pending
= 1;
1060 events
->time_from_event
-= slip
;
1066 sim_events_preprocess (SIM_DESC sd
,
1067 int events_were_last
,
1068 int events_were_next
)
1070 sim_events
*events
= STATE_EVENTS(sd
);
1071 if (events_were_last
)
1073 /* Halted part way through event processing */
1074 ASSERT (events
->nr_ticks_to_process
!= 0);
1075 /* The external world can't tell if the event that stopped the
1076 simulator was the last event to process. */
1077 ASSERT (events_were_next
);
1078 sim_events_process (sd
);
1080 else if (events_were_next
)
1082 /* Halted by the last processor */
1083 if (sim_events_tick (sd
))
1084 sim_events_process (sd
);
1091 sim_events_process (SIM_DESC sd
)
1093 sim_events
*events
= STATE_EVENTS(sd
);
1094 signed64 event_time
= sim_events_time(sd
);
1096 /* Clear work_pending before checking nr_held. Clearing
1097 work_pending after nr_held (with out a lock could loose an
1099 events
->work_pending
= 0;
1101 /* move any events that were asynchronously queued by any signal
1102 handlers onto the real event queue. */
1103 if (events
->nr_held
> 0)
1107 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
1111 sigfillset(&new_mask
);
1112 sigprocmask(SIG_SETMASK
, &new_mask
, &old_mask
);
1115 for (i
= 0; i
< events
->nr_held
; i
++)
1117 sim_event
*entry
= &events
->held
[i
];
1118 sim_events_schedule (sd
,
1119 entry
->time_of_event
,
1123 events
->nr_held
= 0;
1125 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
1127 sigprocmask(SIG_SETMASK
, &old_mask
, NULL
);
1132 /* Process any watchpoints. Be careful to allow a watchpoint to
1133 appear/disappear under our feet.
1134 To ensure that watchpoints are processed only once per cycle,
1135 they are moved onto a watched queue, this returned to the
1136 watchpoint queue when all queue processing has been
1138 while (events
->watchpoints
!= NULL
)
1140 sim_event
*to_do
= events
->watchpoints
;
1141 events
->watchpoints
= to_do
->next
;
1142 if (sim_watch_valid (sd
, to_do
))
1144 sim_event_handler
*handler
= to_do
->handler
;
1145 void *data
= to_do
->data
;
1147 "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx%s%s\n",
1152 (to_do
->trace
!= NULL
) ? ", " : "",
1153 (to_do
->trace
!= NULL
) ? to_do
->trace
: ""));
1154 sim_events_free (sd
, to_do
);
1159 to_do
->next
= events
->watchedpoints
;
1160 events
->watchedpoints
= to_do
;
1164 /* consume all events for this or earlier times. Be careful to
1165 allow an event to appear/disappear under our feet */
1166 while (events
->queue
->time_of_event
<
1167 (event_time
+ events
->nr_ticks_to_process
))
1169 sim_event
*to_do
= events
->queue
;
1170 sim_event_handler
*handler
= to_do
->handler
;
1171 void *data
= to_do
->data
;
1172 events
->queue
= to_do
->next
;
1173 update_time_from_event (sd
);
1175 "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx%s%s\n",
1180 (to_do
->trace
!= NULL
) ? ", " : "",
1181 (to_do
->trace
!= NULL
) ? to_do
->trace
: ""));
1182 sim_events_free (sd
, to_do
);
1186 /* put things back where they belong ready for the next iteration */
1187 events
->watchpoints
= events
->watchedpoints
;
1188 events
->watchedpoints
= NULL
;
1189 if (events
->watchpoints
!= NULL
)
1190 events
->work_pending
= 1;
1192 /* advance the time */
1193 SIM_ASSERT (events
->time_from_event
>= events
->nr_ticks_to_process
);
1194 SIM_ASSERT (events
->queue
!= NULL
); /* always poll event */
1195 events
->time_from_event
-= events
->nr_ticks_to_process
;
1197 /* this round of processing complete */
1198 events
->nr_ticks_to_process
= 0;