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. A value
114 <= 0 (except when poll-event is being processed) indicates that
115 event processing is due. This variable is decremented once for
116 each iteration of a clock cycle.
118 Initially, the clock is started at time one (0) with TIME_OF_EVENT
119 == 0 and TIME_FROM_EVENT == 0 and with NR_TICKS_TO_PROCESS == 1.
121 Clearly there is a bug in that this code assumes that the absolute
122 time counter will never become greater than 2^62.
124 To avoid the need to use 64bit arithmetic, the event queue always
125 contains at least one event scheduled every 16 000 ticks. This
126 limits the time from event counter to values less than
130 #if !defined (SIM_EVENTS_POLL_RATE)
131 #define SIM_EVENTS_POLL_RATE 0x1000
135 #define _ETRACE sd, NULL
138 #define ETRACE(ARGS) \
143 if (STATE_EVENTS (sd)->trace) \
146 SIM_FILTER_PATH (file, __FILE__); \
147 trace_printf (sd, NULL, "%s:%d: ", file, __LINE__); \
155 /* event queue iterator - don't iterate over the held queue. */
157 STATIC_INLINE_SIM_EVENTS\
159 next_event_queue (SIM_DESC sd
,
163 return &STATE_EVENTS (sd
)->queue
;
164 else if (queue
== &STATE_EVENTS (sd
)->queue
)
165 return &STATE_EVENTS (sd
)->watchpoints
;
166 else if (queue
== &STATE_EVENTS (sd
)->watchpoints
)
167 return &STATE_EVENTS (sd
)->watchedpoints
;
168 else if (queue
== &STATE_EVENTS (sd
)->watchedpoints
)
171 sim_io_error (sd
, "next_event_queue - bad queue");
176 STATIC_INLINE_SIM_EVENTS\
178 sim_events_poll (SIM_DESC sd
,
181 /* just re-schedule in 1000 million ticks time */
182 sim_events_schedule (sd
, SIM_EVENTS_POLL_RATE
, sim_events_poll
, sd
);
183 sim_io_poll_quit (sd
);
187 /* "events" module install handler.
188 This is called via sim_module_install to install the "events" subsystem
189 into the simulator. */
191 STATIC_SIM_EVENTS (MODULE_UNINSTALL_FN
) sim_events_uninstall
;
192 STATIC_SIM_EVENTS (MODULE_INIT_FN
) sim_events_init
;
193 STATIC_SIM_EVENTS (MODULE_RESUME_FN
) sim_events_resume
;
194 STATIC_SIM_EVENTS (MODULE_SUSPEND_FN
) sim_events_suspend
;
198 sim_events_install (SIM_DESC sd
)
200 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
201 sim_module_add_uninstall_fn (sd
, sim_events_uninstall
);
202 sim_module_add_init_fn (sd
, sim_events_init
);
203 sim_module_add_resume_fn (sd
, sim_events_resume
);
204 sim_module_add_suspend_fn (sd
, sim_events_suspend
);
209 /* Suspend/resume the event queue manager when the simulator is not
214 sim_events_resume (SIM_DESC sd
)
216 sim_events
*events
= STATE_EVENTS (sd
);
217 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
218 SIM_ASSERT (events
->resume_wallclock
== 0);
219 events
->resume_wallclock
= sim_elapsed_time_get ();
225 sim_events_suspend (SIM_DESC sd
)
227 sim_events
*events
= STATE_EVENTS (sd
);
228 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
229 SIM_ASSERT (events
->resume_wallclock
!= 0);
230 events
->elapsed_wallclock
+= sim_elapsed_time_since (events
->resume_wallclock
);
231 events
->resume_wallclock
= 0;
236 /* Uninstall the "events" subsystem from the simulator. */
240 sim_events_uninstall (SIM_DESC sd
)
242 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
243 /* FIXME: free buffers, etc. */
249 STATIC_INLINE_SIM_EVENTS\
251 sim_events_zalloc (SIM_DESC sd
)
253 sim_events
*events
= STATE_EVENTS (sd
);
254 sim_event
*new = events
->free_list
;
257 events
->free_list
= new->next
;
258 memset (new, 0, sizeof (*new));
262 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
266 sigfillset(&new_mask
);
267 sigprocmask (SIG_SETMASK
, &new_mask
, &old_mask
);
269 new = ZALLOC (sim_event
);
270 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
272 sigprocmask (SIG_SETMASK
, &old_mask
, NULL
);
278 STATIC_INLINE_SIM_EVENTS\
280 sim_events_free (SIM_DESC sd
,
283 sim_events
*events
= STATE_EVENTS (sd
);
284 dead
->next
= events
->free_list
;
285 events
->free_list
= dead
;
289 /* Initialize the simulator event manager */
293 sim_events_init (SIM_DESC sd
)
295 sim_events
*events
= STATE_EVENTS (sd
);
297 /* drain the interrupt queue */
299 if (events
->held
== NULL
)
300 events
->held
= zalloc (sizeof (sim_event
) * MAX_NR_SIGNAL_SIM_EVENTS
);
302 /* drain the normal queues */
304 sim_event
**queue
= NULL
;
305 while ((queue
= next_event_queue (sd
, queue
)) != NULL
)
307 if (queue
== NULL
) break;
308 while (*queue
!= NULL
)
310 sim_event
*dead
= *queue
;
312 sim_events_free (sd
, dead
);
318 /* wind time back to zero */
319 events
->nr_ticks_to_process
= 1; /* start by doing queue */
320 events
->time_of_event
= 0;
321 events
->time_from_event
= 0;
322 events
->elapsed_wallclock
= 0;
323 events
->resume_wallclock
= 0;
325 /* schedule our initial counter event */
326 sim_events_schedule (sd
, 0, sim_events_poll
, sd
);
328 /* from now on, except when the large-int event is being processed
329 the event queue is non empty */
330 SIM_ASSERT (events
->queue
!= NULL
);
338 sim_events_time (SIM_DESC sd
)
340 sim_events
*events
= STATE_EVENTS (sd
);
341 return (events
->time_of_event
- events
->time_from_event
);
347 sim_events_elapsed_time (SIM_DESC sd
)
349 return (sim_elapsed_time_since (STATE_EVENTS (sd
)->resume_wallclock
)
350 + STATE_EVENTS (sd
)->elapsed_wallclock
);
354 STATIC_INLINE_SIM_EVENTS\
356 update_time_from_event (SIM_DESC sd
)
358 sim_events
*events
= STATE_EVENTS (sd
);
359 signed64 current_time
= sim_events_time (sd
);
360 if (events
->queue
!= NULL
)
362 events
->time_of_event
= events
->queue
->time_of_event
;
363 events
->time_from_event
= (events
->queue
->time_of_event
- current_time
);
367 events
->time_of_event
= current_time
- 1;
368 events
->time_from_event
= -1;
370 SIM_ASSERT (current_time
== sim_events_time (sd
));
374 STATIC_INLINE_SIM_EVENTS\
376 insert_sim_event (SIM_DESC sd
,
377 sim_event
*new_event
,
380 sim_events
*events
= STATE_EVENTS (sd
);
383 signed64 time_of_event
;
386 sim_io_error (sd
, "what is past is past!\n");
388 /* compute when the event should occure */
389 time_of_event
= sim_events_time (sd
) + delta
;
391 /* find the queue insertion point - things are time ordered */
392 prev
= &events
->queue
;
393 curr
= events
->queue
;
394 while (curr
!= NULL
&& time_of_event
>= curr
->time_of_event
)
396 SIM_ASSERT (curr
->next
== NULL
397 || curr
->time_of_event
<= curr
->next
->time_of_event
);
401 SIM_ASSERT (curr
== NULL
|| time_of_event
< curr
->time_of_event
);
404 new_event
->next
= curr
;
406 new_event
->time_of_event
= time_of_event
;
408 /* adjust the time until the first event */
409 update_time_from_event (sd
);
415 sim_events_schedule (SIM_DESC sd
,
417 sim_event_handler
*handler
,
420 sim_event
*new_event
= sim_events_zalloc (sd
);
421 new_event
->data
= data
;
422 new_event
->handler
= handler
;
423 new_event
->watching
= watch_timer
;
424 insert_sim_event(sd
, new_event
, delta_time
);
426 "event scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
427 (long)sim_events_time(sd
),
429 (long)new_event
->time_of_event
,
430 (long)new_event
->handler
,
431 (long)new_event
->data
));
438 sim_events_schedule_after_signal (SIM_DESC sd
,
440 sim_event_handler
*handler
,
443 sim_events
*events
= STATE_EVENTS (sd
);
444 sim_event
*new_event
;
445 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
449 sigfillset(&new_mask
);
450 sigprocmask (SIG_SETMASK
, &new_mask
, &old_mask
);
453 /* allocate an event entry from the signal buffer */
454 new_event
= &events
->held
[events
->nr_held
];
456 if (events
->nr_held
> MAX_NR_SIGNAL_SIM_EVENTS
)
458 sim_engine_abort (NULL
, NULL
, NULL_CIA
,
459 "sim_events_schedule_after_signal - buffer oveflow");
462 new_event
->data
= data
;
463 new_event
->handler
= handler
;
464 new_event
->time_of_event
= delta_time
; /* work it out later */
465 new_event
->next
= NULL
;
467 events
->work_pending
= 1; /* notify main process */
469 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
471 sigprocmask (SIG_SETMASK
, &old_mask
, NULL
);
475 "signal scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
476 (long)sim_events_time(sd
),
478 (long)new_event
->time_of_event
,
479 (long)new_event
->handler
,
480 (long)new_event
->data
));
486 sim_events_watch_clock (SIM_DESC sd
,
487 unsigned delta_ms_time
,
488 sim_event_handler
*handler
,
491 sim_events
*events
= STATE_EVENTS (sd
);
492 sim_event
*new_event
= sim_events_zalloc (sd
);
494 new_event
->watching
= watch_clock
;
496 new_event
->data
= data
;
497 new_event
->handler
= handler
;
499 if (events
->resume_wallclock
== 0)
500 new_event
->wallclock
= (events
->elapsed_wallclock
+ delta_ms_time
);
502 new_event
->wallclock
= (events
->elapsed_wallclock
503 + sim_elapsed_time_since (events
->resume_wallclock
)
506 new_event
->next
= events
->watchpoints
;
507 events
->watchpoints
= new_event
;
508 events
->work_pending
= 1;
510 "event watching clock at %ld - tag 0x%lx - wallclock %ld, handler 0x%lx, data 0x%lx\n",
511 (long)sim_events_time (sd
),
513 (long)new_event
->wallclock
,
514 (long)new_event
->handler
,
515 (long)new_event
->data
));
522 sim_events_watch_sim (SIM_DESC sd
,
529 sim_event_handler
*handler
,
532 sim_events
*events
= STATE_EVENTS (sd
);
533 sim_event
*new_event
= sim_events_zalloc (sd
);
540 case 1: new_event
->watching
= watch_sim_host_1
; break;
541 case 2: new_event
->watching
= watch_sim_host_2
; break;
542 case 4: new_event
->watching
= watch_sim_host_4
; break;
543 case 8: new_event
->watching
= watch_sim_host_8
; break;
544 default: sim_io_error (sd
, "sim_events_watch_sim - invalid nr bytes");
550 case 1: new_event
->watching
= watch_sim_be_1
; break;
551 case 2: new_event
->watching
= watch_sim_be_2
; break;
552 case 4: new_event
->watching
= watch_sim_be_4
; break;
553 case 8: new_event
->watching
= watch_sim_be_8
; break;
554 default: sim_io_error (sd
, "sim_events_watch_sim - invalid nr bytes");
560 case 1: new_event
->watching
= watch_sim_le_1
; break;
561 case 2: new_event
->watching
= watch_sim_le_2
; break;
562 case 4: new_event
->watching
= watch_sim_le_4
; break;
563 case 8: new_event
->watching
= watch_sim_le_8
; break;
564 default: sim_io_error (sd
, "sim_events_watch_sim - invalid nr bytes");
568 sim_io_error (sd
, "sim_events_watch_sim - invalid byte order");
571 new_event
->data
= data
;
572 new_event
->handler
= handler
;
574 new_event
->host_addr
= host_addr
;
576 new_event
->lb64
= lb
;
578 new_event
->ub64
= ub
;
579 new_event
->is_within
= (is_within
!= 0);
581 new_event
->next
= events
->watchpoints
;
582 events
->watchpoints
= new_event
;
583 events
->work_pending
= 1;
585 "event watching host at %ld - tag 0x%lx - host-addr 0x%lx, 0x%lx..0x%lx, handler 0x%lx, data 0x%lx\n",
586 (long)sim_events_time (sd
),
588 (long)new_event
->host_addr
,
591 (long)new_event
->handler
,
592 (long)new_event
->data
));
599 sim_events_watch_core (SIM_DESC sd
,
600 address_word core_addr
,
601 sim_core_maps core_map
,
607 sim_event_handler
*handler
,
610 sim_events
*events
= STATE_EVENTS (sd
);
611 sim_event
*new_event
= sim_events_zalloc (sd
);
618 case 1: new_event
->watching
= watch_core_targ_1
; break;
619 case 2: new_event
->watching
= watch_core_targ_2
; break;
620 case 4: new_event
->watching
= watch_core_targ_4
; break;
621 case 8: new_event
->watching
= watch_core_targ_8
; break;
622 default: sim_io_error (sd
, "sim_events_watch_core - invalid nr bytes");
628 case 1: new_event
->watching
= watch_core_be_1
; break;
629 case 2: new_event
->watching
= watch_core_be_2
; break;
630 case 4: new_event
->watching
= watch_core_be_4
; break;
631 case 8: new_event
->watching
= watch_core_be_8
; break;
632 default: sim_io_error (sd
, "sim_events_watch_core - invalid nr bytes");
638 case 1: new_event
->watching
= watch_core_le_1
; break;
639 case 2: new_event
->watching
= watch_core_le_2
; break;
640 case 4: new_event
->watching
= watch_core_le_4
; break;
641 case 8: new_event
->watching
= watch_core_le_8
; break;
642 default: sim_io_error (sd
, "sim_events_watch_core - invalid nr bytes");
646 sim_io_error (sd
, "sim_events_watch_core - invalid byte order");
649 new_event
->data
= data
;
650 new_event
->handler
= handler
;
652 new_event
->core_addr
= core_addr
;
653 new_event
->core_map
= core_map
;
655 new_event
->lb64
= lb
;
657 new_event
->ub64
= ub
;
658 new_event
->is_within
= (is_within
!= 0);
660 new_event
->next
= events
->watchpoints
;
661 events
->watchpoints
= new_event
;
662 events
->work_pending
= 1;
664 "event watching host at %ld - tag 0x%lx - host-addr 0x%lx, 0x%lx..0x%lx, handler 0x%lx, data 0x%lx\n",
665 (long)sim_events_time (sd
),
667 (long)new_event
->host_addr
,
670 (long)new_event
->handler
,
671 (long)new_event
->data
));
678 sim_events_deschedule (SIM_DESC sd
,
679 sim_event
*event_to_remove
)
681 sim_events
*events
= STATE_EVENTS (sd
);
682 sim_event
*to_remove
= (sim_event
*)event_to_remove
;
683 if (event_to_remove
!= NULL
)
685 sim_event
**queue
= NULL
;
686 while ((queue
= next_event_queue (sd
, queue
)) != NULL
)
688 sim_event
**ptr_to_current
;
689 for (ptr_to_current
= queue
;
690 *ptr_to_current
!= NULL
&& *ptr_to_current
!= to_remove
;
691 ptr_to_current
= &(*ptr_to_current
)->next
);
692 if (*ptr_to_current
== to_remove
)
694 sim_event
*dead
= *ptr_to_current
;
695 *ptr_to_current
= dead
->next
;
697 "event/watch descheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
698 (long) sim_events_time (sd
),
699 (long) event_to_remove
,
700 (long) dead
->time_of_event
,
701 (long) dead
->handler
,
703 sim_events_free (sd
, dead
);
704 update_time_from_event (sd
);
705 SIM_ASSERT ((events
->time_from_event
>= 0) == (events
->queue
!= NULL
));
711 "event/watch descheduled at %ld - tag 0x%lx - not found\n",
712 (long) sim_events_time (sd
),
713 (long) event_to_remove
));
717 STATIC_INLINE_SIM_EVENTS\
719 sim_watch_valid (SIM_DESC sd
,
722 switch (to_do
->watching
)
725 #define WATCH_CORE(N,OP,EXT) \
727 unsigned_##N word = 0; \
728 int nr_read = sim_core_read_buffer (sd, NULL, to_do->core_map, &word, \
729 to_do->core_addr, sizeof (word)); \
731 ok = (nr_read == sizeof (unsigned_##N) \
732 && (to_do->is_within \
733 == (word >= to_do->lb##EXT \
734 && word <= to_do->ub##EXT)));
736 case watch_core_targ_1
:
738 WATCH_CORE (1, T2H
,);
741 case watch_core_targ_2
:
743 WATCH_CORE (2, T2H
,);
746 case watch_core_targ_4
:
748 WATCH_CORE (4, T2H
,);
751 case watch_core_targ_8
:
753 WATCH_CORE (8, T2H
,64);
757 case watch_core_be_1
:
759 WATCH_CORE (1, BE2H
,);
762 case watch_core_be_2
:
764 WATCH_CORE (2, BE2H
,);
767 case watch_core_be_4
:
769 WATCH_CORE (4, BE2H
,);
772 case watch_core_be_8
:
774 WATCH_CORE (8, BE2H
,64);
778 case watch_core_le_1
:
780 WATCH_CORE (1, LE2H
,);
783 case watch_core_le_2
:
785 WATCH_CORE (2, LE2H
,);
788 case watch_core_le_4
:
790 WATCH_CORE (4, LE2H
,);
793 case watch_core_le_8
:
795 WATCH_CORE (8, LE2H
,64);
800 #define WATCH_SIM(N,OP,EXT) \
802 unsigned_##N word = *(unsigned_##N*)to_do->host_addr; \
804 ok = (to_do->is_within \
805 == (word >= to_do->lb##EXT \
806 && word <= to_do->ub##EXT));
808 case watch_sim_host_1
:
810 WATCH_SIM (1, word
= ,);
813 case watch_sim_host_2
:
815 WATCH_SIM (2, word
= ,);
818 case watch_sim_host_4
:
820 WATCH_SIM (4, word
= ,);
823 case watch_sim_host_8
:
825 WATCH_SIM (8, word
= ,64);
831 WATCH_SIM (1, BE2H
,);
836 WATCH_SIM (2, BE2H
,);
841 WATCH_SIM (4, BE2H
,);
846 WATCH_SIM (8, BE2H
,64);
852 WATCH_SIM (1, LE2H
,);
857 WATCH_SIM (1, LE2H
,);
862 WATCH_SIM (1, LE2H
,);
867 WATCH_SIM (1, LE2H
,64);
872 case watch_clock
: /* wallclock */
874 unsigned long elapsed_time
= sim_events_elapsed_time (sd
);
875 return (elapsed_time
>= to_do
->wallclock
);
879 sim_io_error (sd
, "sim_watch_valid - bad switch");
889 sim_events_tick (SIM_DESC sd
)
891 sim_events
*events
= STATE_EVENTS (sd
);
893 /* this should only be called after the previous ticks have been
896 /* Advance the time but *only* if there is nothing to process */
897 if (events
->work_pending
898 || events
->time_from_event
== 0)
900 events
->nr_ticks_to_process
+= 1;
905 events
->time_from_event
-= 1;
913 sim_events_tickn (SIM_DESC sd
,
916 sim_events
*events
= STATE_EVENTS (sd
);
919 /* this should only be called after the previous ticks have been
922 /* Advance the time but *only* if there is nothing to process */
923 if (events
->work_pending
|| events
->time_from_event
< n
)
925 events
->nr_ticks_to_process
+= n
;
930 events
->time_from_event
-= n
;
938 sim_events_slip (SIM_DESC sd
,
941 sim_events
*events
= STATE_EVENTS (sd
);
942 SIM_ASSERT (slip
> 0);
944 /* Flag a ready event with work_pending instead of number of ticks
945 to process so that the time continues to be correct */
946 if (events
->time_from_event
< slip
)
948 events
->work_pending
= 1;
950 events
->time_from_event
-= slip
;
956 sim_events_preprocess (SIM_DESC sd
,
957 int events_were_last
,
958 int events_were_next
)
960 sim_events
*events
= STATE_EVENTS(sd
);
961 if (events_were_last
)
963 /* Halted part way through event processing */
964 ASSERT (events
->nr_ticks_to_process
!= 0);
965 /* The external world can't tell if the event that stopped the
966 simulator was the last event to process. */
967 ASSERT (events_were_next
);
968 sim_events_process (sd
);
970 else if (events_were_next
)
972 /* Halted by the last processor */
973 if (sim_events_tick (sd
))
974 sim_events_process (sd
);
981 sim_events_process (SIM_DESC sd
)
983 sim_events
*events
= STATE_EVENTS(sd
);
984 signed64 event_time
= sim_events_time(sd
);
986 /* Clear work_pending before checking nr_held. Clearing
987 work_pending after nr_held (with out a lock could loose an
989 events
->work_pending
= 0;
991 /* move any events that were asynchronously queued by any signal
992 handlers onto the real event queue. */
993 if (events
->nr_held
> 0)
997 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
1001 sigfillset(&new_mask
);
1002 sigprocmask(SIG_SETMASK
, &new_mask
, &old_mask
);
1005 for (i
= 0; i
< events
->nr_held
; i
++)
1007 sim_event
*entry
= &events
->held
[i
];
1008 sim_events_schedule (sd
,
1009 entry
->time_of_event
,
1013 events
->nr_held
= 0;
1015 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
1017 sigprocmask(SIG_SETMASK
, &old_mask
, NULL
);
1022 /* Process any watchpoints. Be careful to allow a watchpoint to
1023 appear/disappear under our feet.
1024 To ensure that watchpoints are processed only once per cycle,
1025 they are moved onto a watched queue, this returned to the
1026 watchpoint queue when all queue processing has been
1028 while (events
->watchpoints
!= NULL
)
1030 sim_event
*to_do
= events
->watchpoints
;
1031 events
->watchpoints
= to_do
->next
;
1032 if (sim_watch_valid (sd
, to_do
))
1034 sim_event_handler
*handler
= to_do
->handler
;
1035 void *data
= to_do
->data
;
1037 "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx\n",
1042 sim_events_free (sd
, to_do
);
1047 to_do
->next
= events
->watchedpoints
;
1048 events
->watchedpoints
= to_do
;
1052 /* consume all events for this or earlier times. Be careful to
1053 allow an event to appear/disappear under our feet */
1054 while (events
->queue
->time_of_event
<
1055 (event_time
+ events
->nr_ticks_to_process
))
1057 sim_event
*to_do
= events
->queue
;
1058 sim_event_handler
*handler
= to_do
->handler
;
1059 void *data
= to_do
->data
;
1060 events
->queue
= to_do
->next
;
1061 update_time_from_event (sd
);
1063 "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx\n",
1068 sim_events_free (sd
, to_do
);
1072 /* put things back where they belong ready for the next iteration */
1073 events
->watchpoints
= events
->watchedpoints
;
1074 events
->watchedpoints
= NULL
;
1075 if (events
->watchpoints
!= NULL
)
1076 events
->work_pending
= 1;
1078 /* advance the time */
1079 SIM_ASSERT (events
->time_from_event
>= events
->nr_ticks_to_process
);
1080 SIM_ASSERT (events
->queue
!= NULL
); /* always poll event */
1081 events
->time_from_event
-= events
->nr_ticks_to_process
;
1083 /* this round of processing complete */
1084 events
->nr_ticks_to_process
= 0;