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"
42 /* core - target byte order */
47 /* core - big-endian */
52 /* core - little-endian */
58 /* sim - host byte order */
63 /* sim - big-endian */
68 /* sim - little-endian */
79 } sim_event_watchpoints
;
83 sim_event_watchpoints watching
;
85 sim_event_handler
*handler
;
87 signed64 time_of_event
;
88 /* watch wallclock event */
90 /* watch core address */
91 address_word core_addr
;
92 sim_core_maps core_map
;
95 /* watch core/sim range */
96 int is_within
; /* 0/1 */
106 /* The event queue maintains a single absolute time using two
109 TIME_OF_EVENT: this holds the time at which the next event is ment
110 to occure. If no next event it will hold the time of the last
113 TIME_FROM_EVENT: The current distance from TIME_OF_EVENT. If an
114 event is pending, this will be positive. If no future event is
115 pending (eg when poll-event is being processed) this will be
116 negative. This variable is decremented once for each iteration of
119 Initially, the clock is started at time one (0) with TIME_OF_EVENT
120 == 0 and TIME_FROM_EVENT == 0.
122 Clearly there is a bug in that this code assumes that the absolute
123 time counter will never become greater than 2^62.
125 To avoid the need to use 64bit arithmetic, the event queue always
126 contains at least one event scheduled every 16 000 ticks. This
127 limits the time from event counter to values less than
131 #if !defined (SIM_EVENTS_POLL_RATE)
132 #define SIM_EVENTS_POLL_RATE 0x100000
139 #define ETRACE(ARGS) \
144 if (STATE_EVENTS (sd)->trace) \
147 SIM_FILTER_PATH (file, __FILE__); \
148 sim_io_printf (sd, "%s:%d: ", file, __LINE__); \
149 sim_io_printf ARGS; \
156 /* event queue iterator - don't iterate over the held queue. */
158 STATIC_INLINE_SIM_EVENTS\
160 next_event_queue (SIM_DESC sd
,
164 return &STATE_EVENTS (sd
)->queue
;
165 else if (queue
== &STATE_EVENTS (sd
)->queue
)
166 return &STATE_EVENTS (sd
)->watchpoints
;
167 else if (queue
== &STATE_EVENTS (sd
)->watchpoints
)
168 return &STATE_EVENTS (sd
)->watchedpoints
;
169 else if (queue
== &STATE_EVENTS (sd
)->watchedpoints
)
172 sim_io_error (sd
, "next_event_queue - bad queue");
177 STATIC_INLINE_SIM_EVENTS\
179 sim_events_poll (SIM_DESC sd
,
182 /* just re-schedule in 1000 million ticks time */
183 sim_events_schedule (sd
, SIM_EVENTS_POLL_RATE
, sim_events_poll
, sd
);
184 sim_io_poll_quit (sd
);
188 /* "events" module install handler.
189 This is called via sim_module_install to install the "events" subsystem
190 into the simulator. */
192 STATIC_SIM_EVENTS (MODULE_UNINSTALL_FN
) sim_events_uninstall
;
193 STATIC_SIM_EVENTS (MODULE_INIT_FN
) sim_events_init
;
194 STATIC_SIM_EVENTS (MODULE_RESUME_FN
) sim_events_resume
;
195 STATIC_SIM_EVENTS (MODULE_SUSPEND_FN
) sim_events_suspend
;
199 sim_events_install (SIM_DESC sd
)
201 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
202 sim_module_add_uninstall_fn (sd
, sim_events_uninstall
);
203 sim_module_add_init_fn (sd
, sim_events_init
);
204 sim_module_add_resume_fn (sd
, sim_events_resume
);
205 sim_module_add_suspend_fn (sd
, sim_events_suspend
);
210 /* Suspend/resume the event queue manager when the simulator is not
215 sim_events_resume (SIM_DESC sd
)
217 sim_events
*events
= STATE_EVENTS (sd
);
218 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
219 SIM_ASSERT (events
->resume_wallclock
== 0);
220 events
->resume_wallclock
= sim_elapsed_time_get ();
226 sim_events_suspend (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
->elapsed_wallclock
+= sim_elapsed_time_since (events
->resume_wallclock
);
232 events
->resume_wallclock
= 0;
237 /* Uninstall the "events" subsystem from the simulator. */
241 sim_events_uninstall (SIM_DESC sd
)
243 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
244 /* FIXME: free buffers, etc. */
250 STATIC_INLINE_SIM_EVENTS\
252 sim_events_zalloc (SIM_DESC sd
)
254 sim_events
*events
= STATE_EVENTS (sd
);
255 sim_event
*new = events
->free_list
;
258 events
->free_list
= new->next
;
259 memset (new, 0, sizeof (*new));
263 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
267 sigfillset(&new_mask
);
268 sigprocmask (SIG_SETMASK
, &new_mask
, &old_mask
);
270 new = ZALLOC (sim_event
);
271 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
273 sigprocmask (SIG_SETMASK
, &old_mask
, NULL
);
279 STATIC_INLINE_SIM_EVENTS\
281 sim_events_free (SIM_DESC sd
,
284 sim_events
*events
= STATE_EVENTS (sd
);
285 dead
->next
= events
->free_list
;
286 events
->free_list
= dead
;
290 /* Initialize the simulator event manager */
294 sim_events_init (SIM_DESC sd
)
296 sim_events
*events
= STATE_EVENTS (sd
);
298 /* drain the interrupt queue */
300 if (events
->held
== NULL
)
301 events
->held
= zalloc (sizeof (sim_event
) * MAX_NR_SIGNAL_SIM_EVENTS
);
303 /* drain the normal queues */
305 sim_event
**queue
= NULL
;
306 while ((queue
= next_event_queue (sd
, queue
)) != NULL
)
308 if (queue
== NULL
) break;
309 while (*queue
!= NULL
)
311 sim_event
*dead
= *queue
;
313 sim_events_free (sd
, dead
);
319 /* wind time back to zero */
320 events
->nr_ticks_to_process
= 1; /* start by doing queue */
321 events
->time_of_event
= 0;
322 events
->time_from_event
= 0;
323 events
->elapsed_wallclock
= 0;
324 events
->resume_wallclock
= 0;
326 /* schedule our initial counter event */
327 sim_events_schedule (sd
, 0, sim_events_poll
, sd
);
329 /* from now on, except when the large-int event is being processed
330 the event queue is non empty */
331 SIM_ASSERT (events
->queue
!= NULL
);
339 sim_events_time (SIM_DESC sd
)
341 sim_events
*events
= STATE_EVENTS (sd
);
342 return events
->time_of_event
- events
->time_from_event
;
346 STATIC_INLINE_SIM_EVENTS\
348 update_time_from_event (SIM_DESC sd
)
350 sim_events
*events
= STATE_EVENTS (sd
);
351 signed64 current_time
= sim_events_time (sd
);
352 if (events
->queue
!= NULL
)
354 events
->time_from_event
= (events
->queue
->time_of_event
- current_time
);
355 events
->time_of_event
= events
->queue
->time_of_event
;
359 events
->time_of_event
= current_time
- 1;
360 events
->time_from_event
= -1;
362 SIM_ASSERT (current_time
== sim_events_time (sd
));
363 SIM_ASSERT ((events
->time_from_event
>= 0) == (events
->queue
!= NULL
));
367 STATIC_INLINE_SIM_EVENTS\
369 insert_sim_event (SIM_DESC sd
,
370 sim_event
*new_event
,
373 sim_events
*events
= STATE_EVENTS (sd
);
376 signed64 time_of_event
;
379 sim_io_error (sd
, "what is past is past!\n");
381 /* compute when the event should occure */
382 time_of_event
= sim_events_time (sd
) + delta
;
384 /* find the queue insertion point - things are time ordered */
385 prev
= &events
->queue
;
386 curr
= events
->queue
;
387 while (curr
!= NULL
&& time_of_event
>= curr
->time_of_event
)
389 SIM_ASSERT (curr
->next
== NULL
390 || curr
->time_of_event
<= curr
->next
->time_of_event
);
394 SIM_ASSERT (curr
== NULL
|| time_of_event
< curr
->time_of_event
);
397 new_event
->next
= curr
;
399 new_event
->time_of_event
= time_of_event
;
401 /* adjust the time until the first event */
402 update_time_from_event (sd
);
408 sim_events_schedule (SIM_DESC sd
,
410 sim_event_handler
*handler
,
413 sim_event
*new_event
= sim_events_zalloc (sd
);
414 new_event
->data
= data
;
415 new_event
->handler
= handler
;
416 new_event
->watching
= watch_timer
;
417 insert_sim_event(sd
, new_event
, delta_time
);
419 "event scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
420 (long)sim_events_time(sd
),
422 (long)new_event
->time_of_event
,
423 (long)new_event
->handler
,
424 (long)new_event
->data
));
431 sim_events_schedule_after_signal (SIM_DESC sd
,
433 sim_event_handler
*handler
,
436 sim_events
*events
= STATE_EVENTS (sd
);
437 sim_event
*new_event
;
438 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
442 sigfillset(&new_mask
);
443 sigprocmask (SIG_SETMASK
, &new_mask
, &old_mask
);
446 /* allocate an event entry from the signal buffer */
447 new_event
= &events
->held
[events
->nr_held
];
449 if (events
->nr_held
> MAX_NR_SIGNAL_SIM_EVENTS
)
451 sim_engine_abort (NULL
, NULL
, NULL_CIA
,
452 "sim_events_schedule_after_signal - buffer oveflow");
455 new_event
->data
= data
;
456 new_event
->handler
= handler
;
457 new_event
->time_of_event
= delta_time
; /* work it out later */
458 new_event
->next
= NULL
;
460 events
->work_pending
= 1; /* notify main process */
462 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
464 sigprocmask (SIG_SETMASK
, &old_mask
, NULL
);
468 "signal scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
469 (long)sim_events_time(sd
),
471 (long)new_event
->time_of_event
,
472 (long)new_event
->handler
,
473 (long)new_event
->data
));
479 sim_events_watch_clock (SIM_DESC sd
,
480 unsigned delta_ms_time
,
481 sim_event_handler
*handler
,
484 sim_events
*events
= STATE_EVENTS (sd
);
485 sim_event
*new_event
= sim_events_zalloc (sd
);
487 new_event
->watching
= watch_clock
;
489 new_event
->data
= data
;
490 new_event
->handler
= handler
;
492 if (events
->resume_wallclock
== 0)
493 new_event
->wallclock
= (events
->elapsed_wallclock
+ delta_ms_time
);
495 new_event
->wallclock
= (events
->elapsed_wallclock
496 + sim_elapsed_time_since (events
->resume_wallclock
)
499 new_event
->next
= events
->watchpoints
;
500 events
->watchpoints
= new_event
;
501 events
->work_pending
= 1;
503 "event watching clock at %ld - tag 0x%lx - wallclock %ld, handler 0x%lx, data 0x%lx\n",
504 (long)sim_events_time (sd
),
506 (long)new_event
->wallclock
,
507 (long)new_event
->handler
,
508 (long)new_event
->data
));
515 sim_events_watch_sim (SIM_DESC sd
,
522 sim_event_handler
*handler
,
525 sim_events
*events
= STATE_EVENTS (sd
);
526 sim_event
*new_event
= sim_events_zalloc (sd
);
533 case 1: new_event
->watching
= watch_sim_host_1
; break;
534 case 2: new_event
->watching
= watch_sim_host_2
; break;
535 case 4: new_event
->watching
= watch_sim_host_4
; break;
536 case 8: new_event
->watching
= watch_sim_host_8
; break;
537 default: sim_io_error (sd
, "sim_events_watch_sim - invalid nr bytes");
543 case 1: new_event
->watching
= watch_sim_be_1
; break;
544 case 2: new_event
->watching
= watch_sim_be_2
; break;
545 case 4: new_event
->watching
= watch_sim_be_4
; break;
546 case 8: new_event
->watching
= watch_sim_be_8
; break;
547 default: sim_io_error (sd
, "sim_events_watch_sim - invalid nr bytes");
553 case 1: new_event
->watching
= watch_sim_le_1
; break;
554 case 2: new_event
->watching
= watch_sim_le_2
; break;
555 case 4: new_event
->watching
= watch_sim_le_4
; break;
556 case 8: new_event
->watching
= watch_sim_le_8
; break;
557 default: sim_io_error (sd
, "sim_events_watch_sim - invalid nr bytes");
561 sim_io_error (sd
, "sim_events_watch_sim - invalid byte order");
564 new_event
->data
= data
;
565 new_event
->handler
= handler
;
567 new_event
->host_addr
= host_addr
;
569 new_event
->lb64
= lb
;
571 new_event
->ub64
= ub
;
572 new_event
->is_within
= (is_within
!= 0);
574 new_event
->next
= events
->watchpoints
;
575 events
->watchpoints
= new_event
;
576 events
->work_pending
= 1;
578 "event watching host at %ld - tag 0x%lx - host-addr 0x%lx, 0x%lx..0x%lx, handler 0x%lx, data 0x%lx\n",
579 (long)sim_events_time (sd
),
581 (long)new_event
->host_addr
,
584 (long)new_event
->handler
,
585 (long)new_event
->data
));
592 sim_events_watch_core (SIM_DESC sd
,
593 address_word core_addr
,
594 sim_core_maps core_map
,
600 sim_event_handler
*handler
,
603 sim_events
*events
= STATE_EVENTS (sd
);
604 sim_event
*new_event
= sim_events_zalloc (sd
);
611 case 1: new_event
->watching
= watch_core_targ_1
; break;
612 case 2: new_event
->watching
= watch_core_targ_2
; break;
613 case 4: new_event
->watching
= watch_core_targ_4
; break;
614 case 8: new_event
->watching
= watch_core_targ_8
; break;
615 default: sim_io_error (sd
, "sim_events_watch_core - invalid nr bytes");
621 case 1: new_event
->watching
= watch_core_be_1
; break;
622 case 2: new_event
->watching
= watch_core_be_2
; break;
623 case 4: new_event
->watching
= watch_core_be_4
; break;
624 case 8: new_event
->watching
= watch_core_be_8
; break;
625 default: sim_io_error (sd
, "sim_events_watch_core - invalid nr bytes");
631 case 1: new_event
->watching
= watch_core_le_1
; break;
632 case 2: new_event
->watching
= watch_core_le_2
; break;
633 case 4: new_event
->watching
= watch_core_le_4
; break;
634 case 8: new_event
->watching
= watch_core_le_8
; break;
635 default: sim_io_error (sd
, "sim_events_watch_core - invalid nr bytes");
639 sim_io_error (sd
, "sim_events_watch_core - invalid byte order");
642 new_event
->data
= data
;
643 new_event
->handler
= handler
;
645 new_event
->core_addr
= core_addr
;
646 new_event
->core_map
= core_map
;
648 new_event
->lb64
= lb
;
650 new_event
->ub64
= ub
;
651 new_event
->is_within
= (is_within
!= 0);
653 new_event
->next
= events
->watchpoints
;
654 events
->watchpoints
= new_event
;
655 events
->work_pending
= 1;
657 "event watching host at %ld - tag 0x%lx - host-addr 0x%lx, 0x%lx..0x%lx, handler 0x%lx, data 0x%lx\n",
658 (long)sim_events_time (sd
),
660 (long)new_event
->host_addr
,
663 (long)new_event
->handler
,
664 (long)new_event
->data
));
671 sim_events_deschedule (SIM_DESC sd
,
672 sim_event
*event_to_remove
)
674 sim_events
*events
= STATE_EVENTS (sd
);
675 sim_event
*to_remove
= (sim_event
*)event_to_remove
;
676 SIM_ASSERT ((events
->time_from_event
>= 0) == (events
->queue
!= NULL
));
677 if (event_to_remove
!= NULL
)
679 sim_event
**queue
= NULL
;
680 while ((queue
= next_event_queue (sd
, queue
)) != NULL
)
682 sim_event
**ptr_to_current
;
683 for (ptr_to_current
= queue
;
684 *ptr_to_current
!= NULL
&& *ptr_to_current
!= to_remove
;
685 ptr_to_current
= &(*ptr_to_current
)->next
);
686 if (*ptr_to_current
== to_remove
)
688 sim_event
*dead
= *ptr_to_current
;
689 *ptr_to_current
= dead
->next
;
691 "event/watch descheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
692 (long) sim_events_time (sd
),
693 (long) event_to_remove
,
694 (long) dead
->time_of_event
,
695 (long) dead
->handler
,
697 sim_events_free (sd
, dead
);
698 update_time_from_event (sd
);
699 SIM_ASSERT ((events
->time_from_event
>= 0) == (events
->queue
!= NULL
));
705 "event/watch descheduled at %ld - tag 0x%lx - not found\n",
706 (long) sim_events_time (sd
),
707 (long) event_to_remove
));
711 STATIC_INLINE_SIM_EVENTS\
713 sim_watch_valid (SIM_DESC sd
,
716 switch (to_do
->watching
)
719 #define WATCH_CORE(N,OP,EXT) \
721 unsigned_##N word = 0; \
722 int nr_read = sim_core_read_buffer (sd, NULL, to_do->core_map, &word, \
723 to_do->core_addr, sizeof (word)); \
725 ok = (nr_read == sizeof (unsigned_##N) \
726 && (to_do->is_within \
727 == (word >= to_do->lb##EXT \
728 && word <= to_do->ub##EXT)));
730 case watch_core_targ_1
:
732 WATCH_CORE (1, T2H
,);
735 case watch_core_targ_2
:
737 WATCH_CORE (2, T2H
,);
740 case watch_core_targ_4
:
742 WATCH_CORE (4, T2H
,);
745 case watch_core_targ_8
:
747 WATCH_CORE (8, T2H
,64);
751 case watch_core_be_1
:
753 WATCH_CORE (1, BE2H
,);
756 case watch_core_be_2
:
758 WATCH_CORE (2, BE2H
,);
761 case watch_core_be_4
:
763 WATCH_CORE (4, BE2H
,);
766 case watch_core_be_8
:
768 WATCH_CORE (8, BE2H
,64);
772 case watch_core_le_1
:
774 WATCH_CORE (1, LE2H
,);
777 case watch_core_le_2
:
779 WATCH_CORE (2, LE2H
,);
782 case watch_core_le_4
:
784 WATCH_CORE (4, LE2H
,);
787 case watch_core_le_8
:
789 WATCH_CORE (8, LE2H
,64);
794 #define WATCH_SIM(N,OP,EXT) \
796 unsigned_##N word = *(unsigned_##N*)to_do->host_addr; \
798 ok = (to_do->is_within \
799 == (word >= to_do->lb##EXT \
800 && word <= to_do->ub##EXT));
802 case watch_sim_host_1
:
804 WATCH_SIM (1, word
= ,);
807 case watch_sim_host_2
:
809 WATCH_SIM (2, word
= ,);
812 case watch_sim_host_4
:
814 WATCH_SIM (4, word
= ,);
817 case watch_sim_host_8
:
819 WATCH_SIM (8, word
= ,64);
825 WATCH_SIM (1, BE2H
,);
830 WATCH_SIM (2, BE2H
,);
835 WATCH_SIM (4, BE2H
,);
840 WATCH_SIM (8, BE2H
,64);
846 WATCH_SIM (1, LE2H
,);
851 WATCH_SIM (1, LE2H
,);
856 WATCH_SIM (1, LE2H
,);
861 WATCH_SIM (1, LE2H
,64);
866 case watch_clock
: /* wallclock */
868 unsigned long elapsed_time
=
869 (sim_elapsed_time_since (STATE_EVENTS (sd
)->resume_wallclock
)
870 + STATE_EVENTS (sd
)->elapsed_wallclock
);
871 return (elapsed_time
>= to_do
->wallclock
);
875 sim_io_error (sd
, "sim_watch_valid - bad switch");
885 sim_events_tick (SIM_DESC sd
)
887 sim_events
*events
= STATE_EVENTS (sd
);
889 /* this should only be called after the previous ticks have been
891 SIM_ASSERT (events
->nr_ticks_to_process
== 0);
893 /* Advance the time but *only* if there is nothing to process */
894 if (events
->work_pending
895 || events
->time_from_event
== 0)
897 events
->nr_ticks_to_process
= 1;
901 events
->time_from_event
-= 1;
909 sim_events_tickn (SIM_DESC sd
,
912 sim_events
*events
= STATE_EVENTS (sd
);
914 /* this should only be called after the previous ticks have been
916 SIM_ASSERT (events
->nr_ticks_to_process
== 0);
919 /* Advance the time but *only* if there is nothing to process */
920 if (events
->work_pending
921 || events
->time_from_event
< n
)
923 events
->nr_ticks_to_process
= n
;
927 events
->time_from_event
-= n
;
935 sim_events_preprocess (SIM_DESC sd
,
936 int events_were_last
,
937 int events_were_next
)
939 sim_events
*events
= STATE_EVENTS(sd
);
940 if (events
->nr_ticks_to_process
!= 0)
942 /* Halted midway through event processing */
943 ASSERT (events_were_last
&& events_were_next
);
944 sim_events_process (sd
);
946 else if (events_were_next
)
948 /* Halted by the last processor */
949 ASSERT (events
->nr_ticks_to_process
== 0 && !events_were_last
);
950 if (sim_events_tick (sd
))
951 sim_events_process (sd
);
958 sim_events_process (SIM_DESC sd
)
960 sim_events
*events
= STATE_EVENTS(sd
);
961 signed64 event_time
= sim_events_time(sd
);
963 ASSERT (events
->nr_ticks_to_process
!= 0);
965 /* move any events that were queued by any signal handlers onto
966 the real event queue. */
967 if (events
->nr_held
> 0)
971 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
975 sigfillset(&new_mask
);
976 sigprocmask(SIG_SETMASK
, &new_mask
, &old_mask
);
979 for (i
= 0; i
< events
->nr_held
; i
++)
981 sim_event
*entry
= &events
->held
[i
];
982 sim_events_schedule (sd
,
983 entry
->time_of_event
,
989 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
991 sigprocmask(SIG_SETMASK
, &old_mask
, NULL
);
996 /* Process any watchpoints. Be careful to allow a watchpoint to
997 appear/disappear under our feet.
998 To ensure that watchpoints are processed only once per cycle,
999 they are moved onto a watched queue, this returned to the
1000 watchpoint queue when all queue processing has been
1002 while (events
->watchpoints
!= NULL
)
1004 sim_event
*to_do
= events
->watchpoints
;
1005 events
->watchpoints
= to_do
->next
;
1006 if (sim_watch_valid (sd
, to_do
))
1008 sim_event_handler
*handler
= to_do
->handler
;
1009 void *data
= to_do
->data
;
1011 "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx\n",
1016 sim_events_free (sd
, to_do
);
1021 to_do
->next
= events
->watchedpoints
;
1022 events
->watchedpoints
= to_do
;
1026 /* consume all events for this or earlier times. Be careful to
1027 allow an event to appear/disappear under our feet */
1028 while (events
->queue
->time_of_event
<
1029 (event_time
+ events
->nr_ticks_to_process
))
1031 sim_event
*to_do
= events
->queue
;
1032 sim_event_handler
*handler
= to_do
->handler
;
1033 void *data
= to_do
->data
;
1034 events
->queue
= to_do
->next
;
1036 "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx\n",
1041 sim_events_free (sd
, to_do
);
1045 /* put things back where they belong ready for the next iteration */
1046 events
->watchpoints
= events
->watchedpoints
;
1047 events
->watchedpoints
= NULL
;
1048 if (events
->watchpoints
!= NULL
)
1049 events
->work_pending
= 1;
1051 /* re-caculate time for new events then advance the time */
1052 update_time_from_event(sd
);
1053 SIM_ASSERT (events
->time_from_event
>= events
->nr_ticks_to_process
);
1054 SIM_ASSERT (events
->queue
!= NULL
); /* always poll event */
1055 events
->time_from_event
-= events
->nr_ticks_to_process
;
1057 /* this round of processing complete */
1058 events
->nr_ticks_to_process
= 0;