URL
https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk
Subversion Repositories openrisc_2011-10-31
[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [sim/] [common/] [hw-events.c] - Rev 330
Compare with Previous | Blame | View Log
/* Hardware event manager. Copyright (C) 1998, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Contributed by Cygnus Support. This file is part of GDB, the GNU debugger. 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 3 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, see <http://www.gnu.org/licenses/>. */ #include "hw-main.h" #include "hw-base.h" #include "sim-events.h" /* The hw-events object is implemented using sim-events */ struct hw_event { void *data; struct hw *me; hw_event_callback *callback; sim_event *real; struct hw_event_data *entry; }; struct hw_event_data { struct hw_event event; struct hw_event_data *next; }; void create_hw_event_data (struct hw *me) { if (me->events_of_hw != NULL) hw_abort (me, "stray events"); /* NOP */ } void delete_hw_event_data (struct hw *me) { /* Remove the scheduled event. */ while (me->events_of_hw) hw_event_queue_deschedule (me, &me->events_of_hw->event); } /* Pass the H/W event onto the real callback */ static void bounce_hw_event (SIM_DESC sd, void *data) { /* save the data */ struct hw_event_data *entry = (struct hw_event_data *) data; struct hw *me = entry->event.me; void *event_data = entry->event.data; hw_event_callback *callback = entry->event.callback; struct hw_event_data **prev = &me->events_of_hw; while ((*prev) != entry) prev = &(*prev)->next; (*prev) = entry->next; hw_free (me, entry); callback (me, event_data); /* may not return */ } /* Map onto the event functions */ struct hw_event * hw_event_queue_schedule (struct hw *me, signed64 delta_time, hw_event_callback *callback, void *data) { struct hw_event *event; va_list dummy; memset (&dummy, 0, sizeof dummy); event = hw_event_queue_schedule_vtracef (me, delta_time, callback, data, NULL, dummy); return event; } struct hw_event * hw_event_queue_schedule_tracef (struct hw *me, signed64 delta_time, hw_event_callback *callback, void *data, const char *fmt, ...) { struct hw_event *event; va_list ap; va_start (ap, fmt); event = hw_event_queue_schedule_vtracef (me, delta_time, callback, data, fmt, ap); va_end (ap); return event; } struct hw_event * hw_event_queue_schedule_vtracef (struct hw *me, signed64 delta_time, hw_event_callback *callback, void *data, const char *fmt, va_list ap) { struct hw_event_data *entry = HW_ZALLOC (me, struct hw_event_data); entry->next = me->events_of_hw; me->events_of_hw = entry; /* fill it in */ entry->event.entry = entry; entry->event.data = data; entry->event.callback = callback; entry->event.me = me; entry->event.real = sim_events_schedule_vtracef (hw_system (me), delta_time, bounce_hw_event, entry, fmt, ap); return &entry->event; } void hw_event_queue_deschedule (struct hw *me, struct hw_event *event_to_remove) { /* ZAP the event but only if it is still in the event queue. Note that event_to_remove is only de-referenced after its validity has been confirmed. */ struct hw_event_data **prev; for (prev = &me->events_of_hw; (*prev) != NULL; prev = &(*prev)->next) { struct hw_event_data *entry = (*prev); if (&entry->event == event_to_remove) { sim_events_deschedule (hw_system (me), entry->event.real); (*prev) = entry->next; hw_free (me, entry); return; } } } signed64 hw_event_queue_time (struct hw *me) { return sim_events_time (hw_system (me)); } /* Returns the time that remains before the event is raised. */ signed64 hw_event_remain_time (struct hw *me, struct hw_event *event) { signed64 t; t = sim_events_remain_time (hw_system (me), event->real); return t; } /* Only worry about this compling on ANSI systems. Build with `make test-hw-events' in sim/<cpu> directory*/ #if defined (MAIN) #include "sim-main.h" #include <string.h> #include <stdio.h> static void test_handler (struct hw *me, void *data) { int *n = data; if (*n != hw_event_queue_time (me)) abort (); *n = -(*n); } int main (int argc, char **argv) { host_callback *cb = ZALLOC (host_callback); struct sim_state *sd = sim_state_alloc (0, cb); struct hw *me = ZALLOC (struct hw); sim_pre_argv_init (sd, "test-hw-events"); sim_post_argv_init (sd); me->system_of_hw = sd; printf ("Create hw-event-data\n"); { create_hw_alloc_data (me); create_hw_event_data (me); delete_hw_event_data (me); delete_hw_alloc_data (me); } printf ("Create hw-events\n"); { struct hw_event *a; struct hw_event *b; struct hw_event *c; struct hw_event *d; create_hw_alloc_data (me); create_hw_event_data (me); a = hw_event_queue_schedule (me, 0, NULL, NULL); b = hw_event_queue_schedule (me, 1, NULL, NULL); c = hw_event_queue_schedule (me, 2, NULL, NULL); d = hw_event_queue_schedule (me, 1, NULL, NULL); hw_event_queue_deschedule (me, c); hw_event_queue_deschedule (me, b); hw_event_queue_deschedule (me, a); hw_event_queue_deschedule (me, d); c = HW_ZALLOC (me, struct hw_event); hw_event_queue_deschedule (me, b); /* OOPS! */ hw_free (me, c); delete_hw_event_data (me); delete_hw_alloc_data (me); } printf ("Schedule hw-events\n"); { struct hw_event **e; int *n; int i; int nr = 4; e = HW_NZALLOC (me, struct hw_event *, nr); n = HW_NZALLOC (me, int, nr); create_hw_alloc_data (me); create_hw_event_data (me); for (i = 0; i < nr; i++) { n[i] = i; e[i] = hw_event_queue_schedule (me, i, test_handler, &n[i]); } sim_events_preprocess (sd, 1, 1); for (i = 0; i < nr; i++) { if (sim_events_tick (sd)) sim_events_process (sd); } for (i = 0; i < nr; i++) { if (n[i] != -i) abort (); hw_event_queue_deschedule (me, e[i]); } hw_free (me, n); hw_free (me, e); delete_hw_event_data (me); delete_hw_alloc_data (me); } return 0; } #endif