-/* This file is part of the program psim.
+/* The common simulator framework for GDB, the GNU Debugger.
- Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
+ Copyright 2002, 2007-2012 Free Software Foundation, Inc.
- 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 2 of the License, or
- (at your option) any later version.
+ Contributed by Andrew Cagney and Red Hat.
- 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, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
- */
+ This file is part of GDB.
+
+ 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/>. */
#ifndef _SIM_EVENTS_C_
#endif
#endif
-#include <signal.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <signal.h> /* For SIGPROCMASK et al. */
typedef enum {
watch_invalid,
watch_sim_le_2,
watch_sim_le_4,
watch_sim_le_8,
-
+
/* wallclock */
watch_clock,
unsigned wallclock;
/* watch core address */
address_word core_addr;
- sim_core_maps core_map;
+ unsigned core_map;
/* watch sim addr */
void *host_addr;
/* watch core/sim range */
unsigned lb;
unsigned64 ub64;
unsigned64 lb64;
+ /* trace info (if any) */
+ char *trace;
/* list */
sim_event *next;
};
/* The event queue maintains a single absolute time using two
variables.
-
+
TIME_OF_EVENT: this holds the time at which the next event is ment
- to occure. If no next event it will hold the time of the last
+ to occur. If no next event it will hold the time of the last
event.
TIME_FROM_EVENT: The current distance from TIME_OF_EVENT. A value
#define _ETRACE sd, NULL
+#undef ETRACE_P
+#define ETRACE_P (WITH_TRACE && STATE_EVENTS (sd)->trace)
+
#undef ETRACE
#define ETRACE(ARGS) \
do \
{ \
- if (WITH_TRACE) \
+ if (ETRACE_P) \
{ \
- if (STATE_EVENTS (sd)->trace) \
- { \
- const char *file; \
- SIM_FILTER_PATH (file, __FILE__); \
- trace_printf (sd, NULL, "%s:%d: ", file, __LINE__); \
- trace_printf ARGS; \
- } \
+ if (STRACE_DEBUG_P (sd)) \
+ { \
+ const char *file; \
+ SIM_FILTER_PATH (file, __FILE__); \
+ trace_printf (sd, NULL, "%s:%d: ", file, __LINE__); \
+ } \
+ trace_printf ARGS; \
} \
} \
while (0)
/* event queue iterator - don't iterate over the held queue. */
-STATIC_INLINE_SIM_EVENTS\
-(sim_event **)
+#if EXTERN_SIM_EVENTS_P
+static sim_event **
next_event_queue (SIM_DESC sd,
sim_event **queue)
{
sim_io_error (sd, "next_event_queue - bad queue");
return NULL;
}
+#endif
STATIC_INLINE_SIM_EVENTS\
This is called via sim_module_install to install the "events" subsystem
into the simulator. */
+#if EXTERN_SIM_EVENTS_P
STATIC_SIM_EVENTS (MODULE_UNINSTALL_FN) sim_events_uninstall;
STATIC_SIM_EVENTS (MODULE_INIT_FN) sim_events_init;
STATIC_SIM_EVENTS (MODULE_RESUME_FN) sim_events_resume;
STATIC_SIM_EVENTS (MODULE_SUSPEND_FN) sim_events_suspend;
+#endif
-EXTERN_SIM_EVENTS\
-(SIM_RC)
+#if EXTERN_SIM_EVENTS_P
+SIM_RC
sim_events_install (SIM_DESC sd)
{
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
sim_module_add_suspend_fn (sd, sim_events_suspend);
return SIM_RC_OK;
}
+#endif
/* Suspend/resume the event queue manager when the simulator is not
running */
-STATIC_SIM_EVENTS\
-(SIM_RC)
+#if EXTERN_SIM_EVENTS_P
+static SIM_RC
sim_events_resume (SIM_DESC sd)
{
sim_events *events = STATE_EVENTS (sd);
events->resume_wallclock = sim_elapsed_time_get ();
return SIM_RC_OK;
}
+#endif
-STATIC_SIM_EVENTS\
-(SIM_RC)
+#if EXTERN_SIM_EVENTS_P
+static SIM_RC
sim_events_suspend (SIM_DESC sd)
{
sim_events *events = STATE_EVENTS (sd);
events->resume_wallclock = 0;
return SIM_RC_OK;
}
+#endif
/* Uninstall the "events" subsystem from the simulator. */
-STATIC_SIM_EVENTS\
-(void)
+#if EXTERN_SIM_EVENTS_P
+static void
sim_events_uninstall (SIM_DESC sd)
{
SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
/* FIXME: free buffers, etc. */
}
+#endif
/* malloc/free */
-STATIC_INLINE_SIM_EVENTS\
-(sim_event *)
+#if EXTERN_SIM_EVENTS_P
+static sim_event *
sim_events_zalloc (SIM_DESC sd)
{
sim_events *events = STATE_EVENTS (sd);
/*-LOCK-*/
sigset_t old_mask;
sigset_t new_mask;
- sigfillset(&new_mask);
+ sigfillset (&new_mask);
sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
#endif
new = ZALLOC (sim_event);
}
return new;
}
+#endif
STATIC_INLINE_SIM_EVENTS\
(void)
sim_events *events = STATE_EVENTS (sd);
dead->next = events->free_list;
events->free_list = dead;
+ if (dead->trace != NULL)
+ {
+ free (dead->trace); /* NB: asprintf returns a `free' buf */
+ dead->trace = NULL;
+ }
}
/* Initialize the simulator event manager */
-EXTERN_SIM_EVENTS\
-(SIM_RC)
+#if EXTERN_SIM_EVENTS_P
+SIM_RC
sim_events_init (SIM_DESC sd)
{
sim_events *events = STATE_EVENTS (sd);
/* drain the interrupt queue */
events->nr_held = 0;
if (events->held == NULL)
- events->held = zalloc (sizeof (sim_event) * MAX_NR_SIGNAL_SIM_EVENTS);
+ events->held = NZALLOC (sim_event, MAX_NR_SIGNAL_SIM_EVENTS);
/* drain the normal queues */
{
return SIM_RC_OK;
}
+#endif
INLINE_SIM_EVENTS\
(unsigned long)
sim_events_elapsed_time (SIM_DESC sd)
{
- return (sim_elapsed_time_since (STATE_EVENTS (sd)->resume_wallclock)
- + STATE_EVENTS (sd)->elapsed_wallclock);
+ unsigned long elapsed = STATE_EVENTS (sd)->elapsed_wallclock;
+
+ /* Are we being called inside sim_resume?
+ (Is there a simulation in progress?) */
+ if (STATE_EVENTS (sd)->resume_wallclock != 0)
+ elapsed += sim_elapsed_time_since (STATE_EVENTS (sd)->resume_wallclock);
+
+ return elapsed;
+}
+
+
+/* Returns the time that remains before the event is raised. */
+INLINE_SIM_EVENTS\
+(signed64)
+sim_events_remain_time (SIM_DESC sd, sim_event *event)
+{
+ if (event == 0)
+ return 0;
+
+ return (event->time_of_event - sim_events_time (sd));
}
+
STATIC_INLINE_SIM_EVENTS\
(void)
update_time_from_event (SIM_DESC sd)
events->time_of_event = current_time - 1;
events->time_from_event = -1;
}
+ if (ETRACE_P)
+ {
+ sim_event *event;
+ int i;
+ for (event = events->queue, i = 0;
+ event != NULL;
+ event = event->next, i++)
+ {
+ ETRACE ((_ETRACE,
+ "event time-from-event - time %ld, delta %ld - event %d, tag 0x%lx, time %ld, handler 0x%lx, data 0x%lx%s%s\n",
+ (long)current_time,
+ (long)events->time_from_event,
+ i,
+ (long)event,
+ (long)event->time_of_event,
+ (long)event->handler,
+ (long)event->data,
+ (event->trace != NULL) ? ", " : "",
+ (event->trace != NULL) ? event->trace : ""));
+ }
+ }
SIM_ASSERT (current_time == sim_events_time (sd));
}
-STATIC_INLINE_SIM_EVENTS\
-(void)
+#if EXTERN_SIM_EVENTS_P
+static void
insert_sim_event (SIM_DESC sd,
sim_event *new_event,
signed64 delta)
if (delta < 0)
sim_io_error (sd, "what is past is past!\n");
-
- /* compute when the event should occure */
+
+ /* compute when the event should occur */
time_of_event = sim_events_time (sd) + delta;
-
+
/* find the queue insertion point - things are time ordered */
prev = &events->queue;
curr = events->queue;
curr = curr->next;
}
SIM_ASSERT (curr == NULL || time_of_event < curr->time_of_event);
-
+
/* insert it */
new_event->next = curr;
*prev = new_event;
new_event->time_of_event = time_of_event;
-
+
/* adjust the time until the first event */
update_time_from_event (sd);
}
+#endif
-EXTERN_SIM_EVENTS\
-(sim_event *)
+#if EXTERN_SIM_EVENTS_P
+sim_event *
sim_events_schedule (SIM_DESC sd,
signed64 delta_time,
sim_event_handler *handler,
void *data)
{
+ va_list dummy;
+ memset (&dummy, 0, sizeof dummy);
+ return sim_events_schedule_vtracef (sd, delta_time, handler, data,
+ NULL, dummy);
+}
+#endif
+
+
+#if EXTERN_SIM_EVENTS_P
+sim_event *
+sim_events_schedule_tracef (SIM_DESC sd,
+ signed64 delta_time,
+ sim_event_handler *handler,
+ void *data,
+ const char *fmt,
+ ...)
+{
+ sim_event *new_event;
+ va_list ap;
+ va_start (ap, fmt);
+ new_event = sim_events_schedule_vtracef (sd, delta_time, handler, data, fmt, ap);
+ va_end (ap);
+ return new_event;
+}
+#endif
+
+
+#if EXTERN_SIM_EVENTS_P
+sim_event *
+sim_events_schedule_vtracef (SIM_DESC sd,
+ signed64 delta_time,
+ sim_event_handler *handler,
+ void *data,
+ const char *fmt,
+ va_list ap)
+{
sim_event *new_event = sim_events_zalloc (sd);
new_event->data = data;
new_event->handler = handler;
new_event->watching = watch_timer;
- insert_sim_event(sd, new_event, delta_time);
- ETRACE((_ETRACE,
- "event scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
- (long)sim_events_time(sd),
- (long)new_event,
- (long)new_event->time_of_event,
- (long)new_event->handler,
- (long)new_event->data));
+ if (fmt == NULL || !ETRACE_P || vasprintf (&new_event->trace, fmt, ap) < 0)
+ new_event->trace = NULL;
+ insert_sim_event (sd, new_event, delta_time);
+ ETRACE ((_ETRACE,
+ "event scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx%s%s\n",
+ (long)sim_events_time (sd),
+ (long)new_event,
+ (long)new_event->time_of_event,
+ (long)new_event->handler,
+ (long)new_event->data,
+ (new_event->trace != NULL) ? ", " : "",
+ (new_event->trace != NULL) ? new_event->trace : ""));
return new_event;
}
+#endif
-EXTERN_SIM_EVENTS\
-(void)
+#if EXTERN_SIM_EVENTS_P
+void
sim_events_schedule_after_signal (SIM_DESC sd,
signed64 delta_time,
sim_event_handler *handler,
/*-LOCK-*/
sigset_t old_mask;
sigset_t new_mask;
- sigfillset(&new_mask);
+ sigfillset (&new_mask);
sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
#endif
-
+
/* allocate an event entry from the signal buffer */
new_event = &events->held [events->nr_held];
events->nr_held ++;
sim_engine_abort (NULL, NULL, NULL_CIA,
"sim_events_schedule_after_signal - buffer oveflow");
}
-
+
new_event->data = data;
new_event->handler = handler;
new_event->time_of_event = delta_time; /* work it out later */
/*-UNLOCK-*/
sigprocmask (SIG_SETMASK, &old_mask, NULL);
#endif
-
+
ETRACE ((_ETRACE,
"signal scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
- (long)sim_events_time(sd),
+ (long)sim_events_time (sd),
(long)new_event,
(long)new_event->time_of_event,
(long)new_event->handler,
(long)new_event->data));
}
+#endif
-EXTERN_SIM_EVENTS\
-(sim_event *)
+#if EXTERN_SIM_EVENTS_P
+sim_event *
sim_events_watch_clock (SIM_DESC sd,
unsigned delta_ms_time,
sim_event_handler *handler,
(long)new_event->data));
return new_event;
}
+#endif
-EXTERN_SIM_EVENTS\
-(sim_event *)
+#if EXTERN_SIM_EVENTS_P
+sim_event *
sim_events_watch_sim (SIM_DESC sd,
void *host_addr,
int nr_bytes,
(long)new_event->data));
return new_event;
}
+#endif
-EXTERN_SIM_EVENTS\
-(sim_event *)
+#if EXTERN_SIM_EVENTS_P
+sim_event *
sim_events_watch_core (SIM_DESC sd,
address_word core_addr,
- sim_core_maps core_map,
+ unsigned core_map,
int nr_bytes,
int byte_order,
int is_within,
(long)new_event->data));
return new_event;
}
+#endif
-EXTERN_SIM_EVENTS\
-(void)
+#if EXTERN_SIM_EVENTS_P
+void
sim_events_deschedule (SIM_DESC sd,
sim_event *event_to_remove)
{
sim_event *dead = *ptr_to_current;
*ptr_to_current = dead->next;
ETRACE ((_ETRACE,
- "event/watch descheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
+ "event/watch descheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx%s%s\n",
(long) sim_events_time (sd),
(long) event_to_remove,
(long) dead->time_of_event,
(long) dead->handler,
- (long) dead->data));
+ (long) dead->data,
+ (dead->trace != NULL) ? ", " : "",
+ (dead->trace != NULL) ? dead->trace : ""));
sim_events_free (sd, dead);
update_time_from_event (sd);
SIM_ASSERT ((events->time_from_event >= 0) == (events->queue != NULL));
(long) sim_events_time (sd),
(long) event_to_remove));
}
+#endif
STATIC_INLINE_SIM_EVENTS\
int events_were_last,
int events_were_next)
{
- sim_events *events = STATE_EVENTS(sd);
+ sim_events *events = STATE_EVENTS (sd);
if (events_were_last)
{
/* Halted part way through event processing */
(void)
sim_events_process (SIM_DESC sd)
{
- sim_events *events = STATE_EVENTS(sd);
- signed64 event_time = sim_events_time(sd);
+ sim_events *events = STATE_EVENTS (sd);
+ signed64 event_time = sim_events_time (sd);
/* Clear work_pending before checking nr_held. Clearing
work_pending after nr_held (with out a lock could loose an
if (events->nr_held > 0)
{
int i;
-
+
#if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
/*-LOCK-*/
sigset_t old_mask;
sigset_t new_mask;
- sigfillset(&new_mask);
- sigprocmask(SIG_SETMASK, &new_mask, &old_mask);
+ sigfillset (&new_mask);
+ sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
#endif
for (i = 0; i < events->nr_held; i++)
entry->data);
}
events->nr_held = 0;
-
+
#if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
/*-UNLOCK-*/
- sigprocmask(SIG_SETMASK, &old_mask, NULL);
+ sigprocmask (SIG_SETMASK, &old_mask, NULL);
#endif
-
+
}
-
+
/* Process any watchpoints. Be careful to allow a watchpoint to
appear/disappear under our feet.
To ensure that watchpoints are processed only once per cycle,
{
sim_event_handler *handler = to_do->handler;
void *data = to_do->data;
- ETRACE((_ETRACE,
- "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx\n",
- (long) event_time,
- (long) to_do,
- (long) handler,
- (long) data));
+ ETRACE ((_ETRACE,
+ "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx%s%s\n",
+ (long) event_time,
+ (long) to_do,
+ (long) handler,
+ (long) data,
+ (to_do->trace != NULL) ? ", " : "",
+ (to_do->trace != NULL) ? to_do->trace : ""));
sim_events_free (sd, to_do);
handler (sd, data);
}
events->watchedpoints = to_do;
}
}
-
+
/* consume all events for this or earlier times. Be careful to
allow an event to appear/disappear under our feet */
while (events->queue->time_of_event <
void *data = to_do->data;
events->queue = to_do->next;
update_time_from_event (sd);
- ETRACE((_ETRACE,
- "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx\n",
- (long) event_time,
- (long) to_do,
- (long) handler,
- (long) data));
+ ETRACE ((_ETRACE,
+ "event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx%s%s\n",
+ (long) event_time,
+ (long) to_do,
+ (long) handler,
+ (long) data,
+ (to_do->trace != NULL) ? ", " : "",
+ (to_do->trace != NULL) ? to_do->trace : ""));
sim_events_free (sd, to_do);
handler (sd, data);
}
-
+
/* put things back where they belong ready for the next iteration */
events->watchpoints = events->watchedpoints;
events->watchedpoints = NULL;
if (events->watchpoints != NULL)
events->work_pending = 1;
-
+
/* advance the time */
SIM_ASSERT (events->time_from_event >= events->nr_ticks_to_process);
SIM_ASSERT (events->queue != NULL); /* always poll event */
projects / external / binutils.git / blobdiff