Watchpoint interface.

9 files changed, 912 insertions, 275 deletions

diff --git a/sim/common/ChangeLog b/sim/common/ChangeLog
index 6398e02..6dfbdcd 100644
--- a/sim/common/ChangeLog
+++ b/sim/common/ChangeLog
@@ -1,3 +1,64 @@
+Wed May 21 08:47:30 1997  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* cgen-scache.c (scache_option_handler): Add is_command arg.
+
+	* sim-model.c (model_option_handler): Add is_command argument.
+
+	* sim-profile.c (profile_option_handler): Add is_command arg.
+
+	* sim-events.c (sim_watch_valid): Use ub64, lb64 when 64bit value
+ 	involved.
+
+	* sim-module.c (sim_module_add_init_fn): Call init fn in the same
+ 	order that they are registered.
+
+	* sim-options.h (OPTION_HANDLER): Add argument to differentiate
+ 	between option and command line processing.
+
+	* sim-options.c: Include stdlib.h, ctype.h.
+
+	* Make-common.in (sim-watch.o): Add rule.
+	(sim_main_headers): Assume sim-assert.h included.
+	(sim-*.o): Simplify make rule.
+	
+	* sim-module.c: Add sim_watch_install to module list.
+
+Tue May 20 14:15:23 1997  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* sim-base.h (STATE_LOADED_P): New predicate. Set once everything
+ 	has been loaded.
+
+	* sim-trace.c (trace_install): Check magic. Include sim-assert.h.
+	* sim-events.c (sim_events_install): Ditto.
+	* sim-core.c (sim_core_install): Ditto.
+	* sim-model.c (model_install): Ditto.
+	* sim-options.c (standard_install): Ditto.
+	* sim-profile.c (profile_install): Ditto.
+	* sim-reason.c (sim_stop_reason): Ditto.
+	* sim-run.c (sim_engine_run): Ditto.
+	* sim-utils.c (sim_analyze_program): Ditto.
+
+	* sim-module.c (modules): Make profile_install and trace_install
+ 	optional.
+
+	* sim-base.h (STATE_MEM_BASE): Define for flat memory systems.
+
+	* sim-options.c (standard_option_handler): Set the byte order.
+
+	* sim-events.c (sim_events_process): Allow multi tick processing.
+	(sim_events_tickn): New function - multi cycle tick.
+	
+	* sim-events.h (sim_events_tickn, sim_events_timewarp): Add
+ 	prototypes.  Under development.
+	(sim_events): Replace processing with nr_ticks_to_process.
+
+Tue May 20 09:39:22 1997  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* nrun.c (main): Pass callbacks to sim_open instead of using
+ 	sim_set_callbacks.
+
+	* run.c (main): Ditto.
+
 Mon May 19 12:07:22 1997  Andrew Cagney  <cagney@b1.cygnus.com>
 
 	* sim-events.c (sim_events_zalloc): Signal save memory allocator -
diff --git a/sim/common/sim-core.c b/sim/common/sim-core.c
index e9102cf..3b9786c 100644
--- a/sim/common/sim-core.c
+++ b/sim/common/sim-core.c
@@ -34,6 +34,7 @@ EXTERN_SIM_CORE\
 (SIM_RC)
 sim_core_install (SIM_DESC sd)
 {
+  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
   sim_module_add_uninstall_fn (sd, sim_core_uninstall);
   sim_module_add_init_fn (sd, sim_core_init);
   return SIM_RC_OK;
@@ -77,6 +78,40 @@ sim_core_init (SIM_DESC sd)
 
 
 
+#ifndef SIM_CORE_SIGNAL
+#define SIM_CORE_SIGNAL(SD,CPU,CIA,MAP,NR_BYTES,ADDR,TRANSFER,ERROR) \
+sim_core_signal ((SD), (CPU), (CIA), (MAP), (NR_BYTES), (ADDR), (TRANSFER), (ERROR))
+
+static void
+sim_core_signal (SIM_DESC sd,
+		 sim_cpu *cpu,
+		 sim_cia cia,
+		 sim_core_maps map,
+		 int nr_bytes,
+		 address_word addr,
+		 transfer_type transfer,
+		 sim_core_signals sig)
+{
+  const char *copy = (transfer == read_transfer ? "read" : "write");
+  switch (sig)
+    {
+    case sim_core_unmapped_signal:
+      sim_engine_abort (sd, cpu, cia, "sim-core: %d byte %s to unmaped address 0x%lx",
+			nr_bytes, copy, (unsigned long) addr);
+      break;
+    case sim_core_unaligned_signal:
+      sim_engine_abort (sd, cpu, cia, "sim-core: %d byte misaligned %s to address 0x%lx",
+			nr_bytes, copy, (unsigned long) addr);
+      break;
+    default:
+      sim_engine_abort (sd, cpu, cia, "sim_core_signal - internal error - bad switch");
+    }
+}
+
+
+
+#endif
+
 STATIC_INLINE_SIM_CORE\
 (const char *)
 sim_core_map_to_str (sim_core_maps map)
@@ -94,13 +129,13 @@ sim_core_map_to_str (sim_core_maps map)
 STATIC_INLINE_SIM_CORE\
 (sim_core_mapping *)
 new_sim_core_mapping(SIM_DESC sd,
-		 attach_type attach,
-		 int space,
-		 unsigned_word addr,
-		 unsigned nr_bytes,
-		 device *device,
-		 void *buffer,
-		 int free_buffer)
+		     attach_type attach,
+		     int space,
+		     unsigned_word addr,
+		     unsigned nr_bytes,
+		     device *device,
+		     void *buffer,
+		     int free_buffer)
 {
   sim_core_mapping *new_mapping = ZALLOC(sim_core_mapping);
   /* common */
@@ -292,6 +327,7 @@ sim_core_find_mapping(sim_core *core,
 		      sim_core_maps map,
 		      unsigned_word addr,
 		      unsigned nr_bytes,
+		      transfer_type transfer,
 		      int abort, /*either 0 or 1 - hint to inline/-O */
 		      sim_cpu *cpu, /* abort => cpu != NULL */
 		      sim_cia cia)
@@ -309,12 +345,8 @@ sim_core_find_mapping(sim_core *core,
     }
   if (abort)
     {
-      if (cpu == NULL)
-	sim_io_error (NULL, "sim_core_find_map - internal error - can not abort without a processor");
-      else
-	engine_error (CPU_STATE (cpu), cpu, cia,
-		      "access to unmaped address 0x%lx (%d bytes)\n",
-		      (unsigned long) addr, nr_bytes);
+      SIM_CORE_SIGNAL (CPU_STATE (cpu), cpu, cia, map, nr_bytes, addr, transfer,
+		       sim_core_unmapped_signal);
     }
   return NULL;
 }
@@ -342,7 +374,8 @@ sim_core_read_buffer(SIM_DESC sd,
     unsigned_word raddr = addr + count;
     sim_core_mapping *mapping =
       sim_core_find_mapping(STATE_CORE (sd), map,
-			    raddr, 1,
+			    raddr, /*nr-bytes*/1,
+			    read_transfer,
 			    0, NULL, NULL_CIA); /*dont-abort*/
     if (mapping == NULL)
       break;
@@ -383,7 +416,8 @@ sim_core_write_buffer(SIM_DESC sd,
   while (count < len) {
     unsigned_word raddr = addr + count;
     sim_core_mapping *mapping = sim_core_find_mapping(STATE_CORE (sd), map,
-						      raddr, 1,
+						      raddr, /*nr-bytes*/1,
+						      write_transfer,
 						      0, NULL, NULL_CIA); /*dont-abort*/
     if (mapping == NULL)
       break;
diff --git a/sim/common/sim-events.c b/sim/common/sim-events.c
index 00fac12..0053fbb 100644
--- a/sim/common/sim-events.c
+++ b/sim/common/sim-events.c
@@ -25,8 +25,17 @@
 #include "sim-main.h"
 #include "sim-assert.h"
 
+#ifdef HAVE_STRING_H
+#include <string.h>
+#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+
 #include <signal.h>
 
+
 typedef enum {
   watch_invalid,
 
@@ -67,11 +76,11 @@ typedef enum {
 
   /* timer */
   watch_timer,
-} sim_watchpoints;
+} sim_event_watchpoints;
 
 
 struct _sim_event {
-  sim_watchpoints watching;
+  sim_event_watchpoints watching;
   void *data;
   sim_event_handler *handler;
   /* timer event */
@@ -102,8 +111,9 @@ struct _sim_event {
 
    TIME_FROM_EVENT: The current distance from TIME_OF_EVENT.  If an
    event is pending, this will be positive.  If no future event is
-   pending this will be negative.  This variable is decremented once
-   for each iteration of a clock cycle.
+   pending (eg when poll-event is being processed) this will be
+   negative.  This variable is decremented once for each iteration of
+   a clock cycle.
 
    Initially, the clock is started at time one (0) with TIME_OF_EVENT
    == 0 and TIME_FROM_EVENT == 0.
@@ -118,7 +128,7 @@ struct _sim_event {
 
 
 #if !defined (SIM_EVENTS_POLL_RATE)
-#define SIM_EVENTS_POLL_RATE 0x4000
+#define SIM_EVENTS_POLL_RATE 0x100000
 #endif
 
 
@@ -142,7 +152,8 @@ do \
 while (0)
 
 
-/* event queue iterator */
+/* event queue iterator - don't iterate over the held queue. */
+
 STATIC_INLINE_SIM_EVENTS\
 (sim_event **)
 next_event_queue (SIM_DESC sd,
@@ -181,6 +192,7 @@ EXTERN_SIM_EVENTS\
 (SIM_RC)
 sim_events_install (SIM_DESC sd)
 {
+  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
   sim_module_add_uninstall_fn (sd, sim_events_uninstall);
   sim_module_add_init_fn (sd, sim_events_init);
   return SIM_RC_OK;
@@ -197,6 +209,48 @@ sim_events_uninstall (SIM_DESC sd)
 }
 
 
+/* malloc/free */
+
+STATIC_INLINE_SIM_EVENTS\
+(sim_event *)
+sim_events_zalloc (SIM_DESC sd)
+{
+  sim_events *events = STATE_EVENTS (sd);
+  sim_event *new = events->free_list;
+  if (new != NULL)
+    {
+      events->free_list = new->next;
+      memset (new, 0, sizeof (*new));
+    }
+  else
+    {
+#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);
+#endif
+      new = ZALLOC (sim_event);
+#if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
+      /*-UNLOCK-*/
+      sigprocmask (SIG_SETMASK, &old_mask, NULL);
+#endif
+    }
+  return new;
+}
+
+STATIC_INLINE_SIM_EVENTS\
+(void)
+sim_events_free (SIM_DESC sd,
+		 sim_event *dead)
+{
+  sim_events *events = STATE_EVENTS (sd);
+  dead->next = events->free_list;
+  events->free_list = dead;
+}
+
+
 /* Initialize the simulator event manager */
 
 EXTERN_SIM_EVENTS\
@@ -206,27 +260,9 @@ sim_events_init (SIM_DESC sd)
   sim_events *events = STATE_EVENTS (sd);
 
   /* drain the interrupt queue */
-  {
-    sim_event *event;
-#if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
-    sigset_t old_mask;
-    sigset_t new_mask;
-    sigfillset(&new_mask);
-    /*-LOCK-*/ sigprocmask(SIG_SETMASK, &new_mask, &old_mask);
-#endif
-    event = events->held;
-    while (event != NULL) {
-      sim_event *dead = event;
-      event = event->next;
-      zfree(dead);
-    }
-    events->held = NULL;
-    events->held_end = &events->held;
-    events->work_pending = 0;
-#if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
-    /*-UNLOCK-*/ sigprocmask(SIG_SETMASK, &old_mask, NULL);
-#endif
-  }
+  events->nr_held = 0;
+  if (events->held == NULL)
+    events->held = zalloc (sizeof (sim_event) * MAX_NR_SIGNAL_SIM_EVENTS);
 
   /* drain the normal queues */
   {
@@ -238,14 +274,14 @@ sim_events_init (SIM_DESC sd)
 	  {
 	    sim_event *dead = *queue;
 	    *queue = dead->next;
-	    zfree (dead);
+	    sim_events_free (sd, dead);
 	  }
 	*queue = NULL;
       }
   }
 
   /* wind time back to zero */
-  events->processing = 1; /* start by doing queue */
+  events->nr_ticks_to_process = 1; /* start by doing queue */
   events->time_of_event = 0;
   events->time_from_event = 0;
   events->initial_wallclock = sim_elapsed_time_get ();
@@ -337,7 +373,7 @@ sim_events_schedule (SIM_DESC sd,
 		     sim_event_handler *handler,
 		     void *data)
 {
-  sim_event *new_event = ZALLOC(sim_event);
+  sim_event *new_event = sim_events_zalloc (sd);
   new_event->data = data;
   new_event->handler = handler;
   new_event->watching = watch_timer;
@@ -354,70 +390,69 @@ sim_events_schedule (SIM_DESC sd,
 
 
 EXTERN_SIM_EVENTS\
-(sim_event *)
-sim_events_schedule_after_signal(SIM_DESC sd,
-				 signed64 delta_time,
-				 sim_event_handler *handler,
-				 void *data)
+(void)
+sim_events_schedule_after_signal (SIM_DESC sd,
+				  signed64 delta_time,
+				  sim_event_handler *handler,
+				  void *data)
 {
   sim_events *events = STATE_EVENTS (sd);
-  sim_event *new_event = ZALLOC (sim_event);
+  sim_event *new_event;
+#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);
+#endif
+  
+  /* allocate an event entry from the signal buffer */
+  new_event = &events->held [events->nr_held];
+  events->nr_held ++;
+  if (events->nr_held >= MAX_NR_SIGNAL_SIM_EVENTS)
+    {
+      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 */
   new_event->next = NULL;
-  
-  {
-#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);
-#endif
-    if (events->held == NULL) {
-      events->held = new_event;
-    }
-    else {
-      *events->held_end = new_event;
-    }
-    events->held_end = &new_event->next;
-    events->work_pending = 1; /* notify main process */
+
+  events->work_pending = 1; /* notify main process */
+
 #if defined (HAVE_SIGPROCMASK) && defined (SIG_SETMASK)
-    /*-UNLOCK-*/
-    sigprocmask (SIG_SETMASK, &old_mask, NULL);
+  /*-UNLOCK-*/
+  sigprocmask (SIG_SETMASK, &old_mask, NULL);
 #endif
-  }
   
   ETRACE ((_ETRACE,
-	   "event scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
+	   "signal 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));
-  
-  return new_event;
 }
 
 
 EXTERN_SIM_EVENTS\
 (sim_event *)
 sim_events_watch_clock (SIM_DESC sd,
-			unsigned wallclock_ms_time,
+			unsigned delta_ms_time,
 			sim_event_handler *handler,
 			void *data)
 {
   sim_events *events = STATE_EVENTS (sd);
-  sim_event *new_event = ZALLOC (sim_event);
+  sim_event *new_event = sim_events_zalloc (sd);
   /* type */
   new_event->watching = watch_clock;
   /* handler */
   new_event->data = data;
   new_event->handler = handler;
   /* data */
-  new_event->wallclock = wallclock_ms_time;
+  new_event->wallclock = (sim_elapsed_time_since (events->initial_wallclock) + delta_ms_time);
   /* insert */
   new_event->next = events->watchpoints;
   events->watchpoints = new_event;
@@ -445,7 +480,7 @@ sim_events_watch_sim (SIM_DESC sd,
 		      void *data)
 {
   sim_events *events = STATE_EVENTS (sd);
-  sim_event *new_event = ZALLOC (sim_event);
+  sim_event *new_event = sim_events_zalloc (sd);
   /* type */
   switch (byte_order)
     {
@@ -521,7 +556,7 @@ sim_events_watch_core (SIM_DESC sd,
 		       void *data)
 {
   sim_events *events = STATE_EVENTS (sd);
-  sim_event *new_event = ZALLOC (sim_event);
+  sim_event *new_event = sim_events_zalloc (sd);
   /* type */
   switch (byte_order)
     {
@@ -613,7 +648,7 @@ sim_events_deschedule (SIM_DESC sd,
 		       (long) dead->time_of_event,
 		       (long) dead->handler,
 		       (long) dead->data));
-	      zfree (dead);
+	      sim_events_free (sd, dead);
 	      update_time_from_event (sd);
 	      SIM_ASSERT ((events->time_from_event >= 0) == (events->queue != NULL));
 	      return;
@@ -635,60 +670,59 @@ sim_watch_valid (SIM_DESC sd,
   switch (to_do->watching)
     {
 
-#define WATCH_CORE(N,OP) \
+#define WATCH_CORE(N,OP,EXT) \
       { \
 	unsigned_##N word; \
 	sim_core_read_buffer (sd, to_do->core_map, &word, to_do->core_addr, sizeof (word)); \
 	OP (word); \
-	return (word >= to_do->lb && word <= to_do->ub); \
+	return (word >= to_do->lb##EXT && word <= to_do->ub##EXT); \
       }
-
-    case watch_core_targ_1: WATCH_CORE (1, T2H);
-    case watch_core_targ_2: WATCH_CORE (2, T2H);
-    case watch_core_targ_4: WATCH_CORE (4, T2H);
-    case watch_core_targ_8: WATCH_CORE (8, T2H);
-
-    case watch_core_be_1: WATCH_CORE (1, BE2H);
-    case watch_core_be_2: WATCH_CORE (2, BE2H);
-    case watch_core_be_4: WATCH_CORE (4, BE2H);
-    case watch_core_be_8: WATCH_CORE (8, BE2H);
-
-    case watch_core_le_1: WATCH_CORE (1, LE2H);
-    case watch_core_le_2: WATCH_CORE (2, LE2H);
-    case watch_core_le_4: WATCH_CORE (4, LE2H);
-    case watch_core_le_8: WATCH_CORE (8, LE2H);
-
+    case watch_core_targ_1: WATCH_CORE (1, T2H,);
+    case watch_core_targ_2: WATCH_CORE (2, T2H,);
+    case watch_core_targ_4: WATCH_CORE (4, T2H,);
+    case watch_core_targ_8: WATCH_CORE (8, T2H,64);
+
+    case watch_core_be_1: WATCH_CORE (1, BE2H,);
+    case watch_core_be_2: WATCH_CORE (2, BE2H,);
+    case watch_core_be_4: WATCH_CORE (4, BE2H,);
+    case watch_core_be_8: WATCH_CORE (8, BE2H,64);
+
+    case watch_core_le_1: WATCH_CORE (1, LE2H,);
+    case watch_core_le_2: WATCH_CORE (2, LE2H,);
+    case watch_core_le_4: WATCH_CORE (4, LE2H,);
+    case watch_core_le_8: WATCH_CORE (8, LE2H,64);
 #undef WATCH_CORE
 
-#define WATCH_SIM(N,OP) \
+#define WATCH_SIM(N,OP,EXT) \
       { \
 	unsigned_##N word = *(unsigned_##N*)to_do->host_addr; \
         OP (word); \
-	return (word >= to_do->lb && word <= to_do->ub); \
+	return (word >= to_do->lb##EXT && word <= to_do->ub##EXT); \
       }
 
-    case watch_sim_host_1: WATCH_SIM (1, word = );
-    case watch_sim_host_2: WATCH_SIM (2, word = );
-    case watch_sim_host_4: WATCH_SIM (4, word = );
-    case watch_sim_host_8: WATCH_SIM (8, word = );
+    case watch_sim_host_1: WATCH_SIM (1, word = ,);
+    case watch_sim_host_2: WATCH_SIM (2, word = ,);
+    case watch_sim_host_4: WATCH_SIM (4, word = ,);
+    case watch_sim_host_8: WATCH_SIM (8, word = ,64);
 
-    case watch_sim_be_1: WATCH_SIM (1, BE2H);
-    case watch_sim_be_2: WATCH_SIM (2, BE2H);
-    case watch_sim_be_4: WATCH_SIM (4, BE2H);
-    case watch_sim_be_8: WATCH_SIM (8, BE2H);
+    case watch_sim_be_1: WATCH_SIM (1, BE2H,);
+    case watch_sim_be_2: WATCH_SIM (2, BE2H,);
+    case watch_sim_be_4: WATCH_SIM (4, BE2H,);
+    case watch_sim_be_8: WATCH_SIM (8, BE2H,64);
 
-    case watch_sim_le_1: WATCH_SIM (1, LE2H);
-    case watch_sim_le_2: WATCH_SIM (1, LE2H);
-    case watch_sim_le_4: WATCH_SIM (1, LE2H);
-    case watch_sim_le_8: WATCH_SIM (1, LE2H);
+    case watch_sim_le_1: WATCH_SIM (1, LE2H,);
+    case watch_sim_le_2: WATCH_SIM (1, LE2H,);
+    case watch_sim_le_4: WATCH_SIM (1, LE2H,);
+    case watch_sim_le_8: WATCH_SIM (1, LE2H,64);
 #undef WATCH_SIM
 
     case watch_clock: /* wallclock */
-      return (sim_elapsed_time_since (STATE_EVENTS (sd)->initial_wallclock)
-	      < to_do->wallclock);
+      {
+	unsigned long elapsed_time = sim_elapsed_time_since (STATE_EVENTS (sd)->initial_wallclock);
+	return (elapsed_time >= to_do->wallclock);
+      }
 
-    case watch_timer:
-    case watch_invalid:
+    default:
       sim_io_error (sd, "sim_watch_valid - bad switch");
       break;
 
@@ -703,15 +737,15 @@ sim_events_tick (SIM_DESC sd)
 {
   sim_events *events = STATE_EVENTS (sd);
 
-  /* this should only be called after the previous tick has been fully
-     processed */
-  SIM_ASSERT (!events->processing);
+  /* this should only be called after the previous ticks have been
+     fully processed */
+  SIM_ASSERT (events->nr_ticks_to_process == 0);
 
   /* Advance the time but *only* if there is nothing to process */
   if (events->work_pending
       || events->time_from_event == 0)
     {
-      events->processing = 1;
+      events->nr_ticks_to_process = 1;
       return 1;
     }
   else {
@@ -722,13 +756,39 @@ sim_events_tick (SIM_DESC sd)
 
 
 INLINE_SIM_EVENTS\
+(int)
+sim_events_tickn (SIM_DESC sd,
+		  unsigned n)
+{
+  sim_events *events = STATE_EVENTS (sd);
+
+  /* this should only be called after the previous ticks have been
+     fully processed */
+  SIM_ASSERT (events->nr_ticks_to_process == 0);
+  SIM_ASSERT (n > 0);
+
+  /* Advance the time but *only* if there is nothing to process */
+  if (events->work_pending
+      || events->time_from_event < n)
+    {
+      events->nr_ticks_to_process = n;
+      return 1;
+    }
+  else {
+    events->time_from_event -= n;
+    return 0;
+  }
+}
+
+
+INLINE_SIM_EVENTS\
 (void)
 sim_events_preprocess (SIM_DESC sd,
 		       int events_were_last,
 		       int events_were_next)
 {
   sim_events *events = STATE_EVENTS(sd);
-  if (events->processing)
+  if (events->nr_ticks_to_process != 0)
     {
       /* Halted midway through event processing */
       ASSERT (events_were_last && events_were_next);
@@ -737,7 +797,7 @@ sim_events_preprocess (SIM_DESC sd,
   else if (events_were_next)
     {
       /* Halted by the last processor */
-      ASSERT (!events->processing && !events_were_last);
+      ASSERT (events->nr_ticks_to_process == 0 && !events_were_last);
       if (sim_events_tick (sd))
 	sim_events_process (sd);
     }
@@ -751,14 +811,13 @@ sim_events_process (SIM_DESC sd)
   sim_events *events = STATE_EVENTS(sd);
   signed64 event_time = sim_events_time(sd);
 
-  ASSERT (events->processing);
+  ASSERT (events->nr_ticks_to_process != 0);
 
   /* move any events that were queued by any signal handlers onto
      the real event queue.  */
-  if (events->held != NULL)
+  if (events->nr_held > 0)
     {
-      sim_event *held_events;
-      sim_event *curr_event;
+      int i;
       
 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
       /*-LOCK-*/
@@ -768,24 +827,21 @@ sim_events_process (SIM_DESC sd)
       sigprocmask(SIG_SETMASK, &new_mask, &old_mask);
 #endif
       
-      held_events = events->held;
-      events->held = NULL;
-      events->held_end = &events->held;
-      events->work_pending = 0;
+      for (i = 0; i < events->nr_held; i++)
+	{
+	  sim_event *entry = &events->held [i];
+	  sim_events_schedule (sd,
+			       entry->time_of_event,
+			       entry->handler,
+			       entry->data);
+	}
+      events->nr_held = 0;
       
 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
       /*-UNLOCK-*/
       sigprocmask(SIG_SETMASK, &old_mask, NULL);
 #endif
       
-      do
-	{
-	  curr_event = held_events;
-	  held_events = curr_event->next;
-	  insert_sim_event (sd, curr_event,
-			    curr_event->time_of_event);
-	}
-      while (held_events != NULL);
     }
   
   /* Process any watchpoints. Be careful to allow a watchpoint to
@@ -809,7 +865,7 @@ sim_events_process (SIM_DESC sd)
 		  (long) to_do,
 		  (long) handler,
 		  (long) data));
-	  zfree (to_do);
+	  sim_events_free (sd, to_do);
 	  handler (sd, data);
 	}
       else
@@ -821,7 +877,8 @@ sim_events_process (SIM_DESC sd)
   
   /* 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 <= event_time)
+  while (events->queue->time_of_event <
+	 (event_time + events->nr_ticks_to_process))
     {
       sim_event *to_do = events->queue;
       sim_event_handler *handler = to_do->handler;
@@ -833,7 +890,7 @@ sim_events_process (SIM_DESC sd)
 	      (long) to_do,
 	      (long) handler,
 	      (long) data));
-      zfree (to_do);
+      sim_events_free (sd, to_do);
       handler (sd, data);
     }
   
@@ -843,13 +900,14 @@ sim_events_process (SIM_DESC sd)
   if (events->watchpoints != NULL)
     events->work_pending = 1;
   
-  /* this round of processing complete */
-  events->processing = 0;
-  
-  /* re-caculate time for new events - advance the time */
+  /* re-caculate time for new events then advance the time */
   update_time_from_event(sd);
-  SIM_ASSERT(events->time_from_event > 0 && events->queue != NULL);
-  events->time_from_event -= 1;
+  SIM_ASSERT (events->time_from_event >= events->nr_ticks_to_process);
+  SIM_ASSERT (events->queue != NULL); /* always poll event */
+  events->time_from_event -= events->nr_ticks_to_process;
+
+  /* this round of processing complete */
+  events->nr_ticks_to_process = 0;
 }
 
 #endif
diff --git a/sim/common/sim-events.h b/sim/common/sim-events.h
index 8c41927..fffde47 100644
--- a/sim/common/sim-events.h
+++ b/sim/common/sim-events.h
@@ -75,15 +75,19 @@ typedef struct _sim_event sim_event;
 
 typedef struct _sim_events sim_events;
 struct _sim_events {
-  int processing;
+  int nr_ticks_to_process;
   sim_event *queue;
   sim_event *watchpoints;
   sim_event *watchedpoints;
+  sim_event *free_list;
   /* flag additional work needed */
   volatile int work_pending;
   /* the asynchronous event queue */
-  sim_event *volatile held;
-  sim_event *volatile *volatile held_end;
+#ifndef MAX_NR_SIGNAL_SIM_EVENTS
+#define MAX_NR_SIGNAL_SIM_EVENTS 2
+#endif
+  sim_event *held;
+  volatile int nr_held;
   /* timekeeping */
   SIM_ELAPSED_TIME initial_wallclock;
   signed64 time_of_event;
@@ -131,21 +135,20 @@ EXTERN_SIM_EVENTS\
  void *data);
 
 EXTERN_SIM_EVENTS\
-(sim_event *) sim_events_schedule_after_signal
+(void) sim_events_schedule_after_signal
 (SIM_DESC sd,
  signed64 delta_time,
  sim_event_handler *handler,
  void *data);
 
 
-/* Schedule an event WALLCLOCK milli-seconds from the start of the
-   simulation.  The exact interpretation of wallclock is host
-   dependant. */
+/* Schedule an event milli-seconds from NOW.  The exact interpretation
+   of wallclock is host dependant. */
 
 EXTERN_SIM_EVENTS\
 (sim_event *) sim_events_watch_clock
 (SIM_DESC sd,
- unsigned wallclock_ms_time,
+ unsigned delta_ms_time,
  sim_event_handler *handler,
  void *data);
 
@@ -186,7 +189,6 @@ EXTERN_SIM_EVENTS\
  sim_event_handler *handler,
  void *data);
 
-
 /* Deschedule the specified event */
 
 EXTERN_SIM_EVENTS\
@@ -212,17 +214,33 @@ INLINE_SIM_EVENTS\
 
 
 /* Progress time - separated into two parts so that the main loop can
-   save its context before the event queue is processed */
+   save its context before the event queue is processed.
+
+   sim_events_tickn advances the clock by N cycles. */
 
 INLINE_SIM_EVENTS\
 (int) sim_events_tick
 (SIM_DESC sd);
 
 INLINE_SIM_EVENTS\
+(int) sim_events_tickn
+(SIM_DESC sd,
+ unsigned n);
+
+INLINE_SIM_EVENTS\
 (void) sim_events_process
 (SIM_DESC sd);
 
 
+/* Progress time such that an event shall occure upon the next call to
+   sim_events tick */
+
+#if 0
+INLINE_SIM_EVENTS\
+(void) sim_events_timewarp
+(SIM_DESC sd);
+#endif
+
 
 /* local concept of time */
 
diff --git a/sim/common/sim-options.c b/sim/common/sim-options.c
index 5207457..4f8890b 100644
--- a/sim/common/sim-options.c
+++ b/sim/common/sim-options.c
@@ -26,10 +26,15 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <strings.h>
 #endif
 #endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <ctype.h>
 #include "libiberty.h"
 #include "../libiberty/alloca-conf.h"
 #include "sim-options.h"
 #include "sim-io.h"
+#include "sim-assert.h"
 
 /* Add a set of options to the simulator.
    TABLE is an array of OPTIONS terminated by a NULL `opt.name' entry.
@@ -115,7 +120,7 @@ static const OPTION standard_options[] =
 #endif
 
   { {"do-command", required_argument, NULL, OPTION_DO_COMMAND},
-      '\0', "COMMAND", "Perform a builtin command",
+      '\0', "COMMAND", ""/*undocumented*/,
       standard_option_handler },
 
   { {"help", no_argument, NULL, 'H'},
@@ -126,10 +131,11 @@ static const OPTION standard_options[] =
 };
 
 static SIM_RC
-standard_option_handler (sd, opt, arg)
+standard_option_handler (sd, opt, arg, is_command)
      SIM_DESC sd;
      int opt;
      char *arg;
+     int is_command;
 {
   int i,n;
 
@@ -149,6 +155,7 @@ standard_option_handler (sd, opt, arg)
 	      return SIM_RC_FAIL;
 	    }
 	  /* FIXME:wip: Need to set something in STATE_CONFIG.  */
+	  current_target_byte_order = BIG_ENDIAN;
 	}
       else if (strcmp (arg, "little") == 0)
 	{
@@ -158,6 +165,7 @@ standard_option_handler (sd, opt, arg)
 	      return SIM_RC_FAIL;
 	    }
 	  /* FIXME:wip: Need to set something in STATE_CONFIG.  */
+	  current_target_byte_order = LITTLE_ENDIAN;
 	}
       else
 	{
@@ -246,6 +254,7 @@ standard_option_handler (sd, opt, arg)
 SIM_RC
 standard_install (SIM_DESC sd)
 {
+  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
   if (sim_add_option_table (sd, standard_options) != SIM_RC_OK)
     return SIM_RC_FAIL;
   return SIM_RC_OK;
@@ -372,7 +381,7 @@ sim_parse_args (sd, argv)
       if (optc == '?')
 	return SIM_RC_FAIL;
 
-      if ((*handlers[optc]) (sd, orig_val[optc], optarg) == SIM_RC_FAIL)
+      if ((*handlers[optc]) (sd, orig_val[optc], optarg, 0/*!is_command*/) == SIM_RC_FAIL)
 	return SIM_RC_FAIL;
     }
 
@@ -408,6 +417,9 @@ sim_print_help (sd)
 	if (opt->doc == NULL)
 	  continue;
 
+	if (opt->doc_name != NULL && opt->doc_name [0] == '\0')
+	  continue;
+
 	sim_io_printf (sd, "  ");
 
 	comma = 0;
@@ -442,14 +454,19 @@ sim_print_help (sd)
 	o = opt;
 	do
 	  {
-	    if (o->opt.name != NULL)
+	    const char *name;
+	    if (o->doc_name != NULL)
+	      name = o->doc_name;
+	    else
+	      name = o->opt.name;
+	    if (name != NULL)
 	      {
 		sim_io_printf (sd, "%s--%s",
 			       comma ? ", " : "",
-			       o->opt.name);
+			       name);
 		len += ((comma ? 2 : 0)
 			+ 2
-			+ strlen (o->opt.name));
+			+ strlen (name));
 		if (o->arg != NULL)
 		  {
 		    if (o->opt.has_arg == optional_argument)
@@ -515,40 +532,77 @@ sim_args_command (sd, cmd)
       const struct option_list *ol;
       const OPTION *opt;
       char **argv = buildargv (cmd);
-      for (ol = STATE_OPTIONS (sd); ol != NULL; ol = ol->next)
-	for (opt = ol->options; opt->opt.name != NULL; ++opt)
-	  {
-	    if (strcmp (argv[0], opt->opt.name) == 0)
-	      {
-		switch (opt->opt.has_arg)
-		  {
-		  case no_argument:
-		    if (argv[1] == NULL)
-		      opt->handler (sd, opt->opt.val, NULL);
-		    else
-		      sim_io_eprintf (sd, "Command `%s' takes no arguments\n", opt->opt.name);
-		    break;
-		  case optional_argument:
-		    if (argv[1] == NULL)
-		      opt->handler (sd, opt->opt.val, NULL);
-		    else if (argv[2] == NULL)
-		      opt->handler (sd, opt->opt.val, argv[1]);
-		    else
-		      sim_io_eprintf (sd, "Command `%s' requires no more than one argument\n", opt->opt.name);
+      /* most recent option match */
+      const OPTION *matching_opt = NULL;
+      int matching_argi = -1;
+      if (argv [0] != NULL)
+	for (ol = STATE_OPTIONS (sd); ol != NULL; ol = ol->next)
+	  for (opt = ol->options; opt->opt.name != NULL; ++opt)
+	    {
+	      int argi = 0;
+	      const char *name = opt->opt.name;
+	      while (strncmp (name, argv [argi], strlen (argv [argi])) == 0)
+		{
+		  name = &name [strlen (argv[argi])];
+		  if (name [0] == '-')
+		    {
+		      /* leading match ...<a-b-c>-d-e-f - continue search */
+		      name ++; /* skip `-' */
+		      argi ++;
+		      continue;
+		    }
+		  else if (name [0] == '\0')
+		    {
+		      /* exact match ...<a-b-c-d-e-f> - better than before? */
+		      if (argi > matching_argi)
+			{
+			  matching_argi = argi;
+			  matching_opt = opt;
+			}
+		      break;
+		    }
+		  else
 		    break;
-		  case required_argument:
-		    if (argv[1] == NULL)
-		      sim_io_eprintf (sd, "Command `%s' requires an argument\n", opt->opt.name);
-		    else if (argv[2] == NULL)
-		      opt->handler (sd, opt->opt.val, argv[1]);
-		    else
-		      sim_io_eprintf (sd, "Command `%s' requires only one argument\n", opt->opt.name);
-		  }
-		return SIM_RC_OK;
-	      }
-	  }
+		}
+	    }
+      if (matching_opt != NULL)
+	{
+	  switch (matching_opt->opt.has_arg)
+	    {
+	    case no_argument:
+	      if (argv [matching_argi + 1] == NULL)
+		matching_opt->handler (sd, matching_opt->opt.val,
+				       NULL, 1/*is_command*/);
+	      else
+		sim_io_eprintf (sd, "Command `%s' takes no arguments\n",
+				matching_opt->opt.name);
+	      break;
+	    case optional_argument:
+	      if (argv [matching_argi + 1] == NULL)
+		matching_opt->handler (sd, matching_opt->opt.val,
+				       NULL, 1/*is_command*/);
+	      else if (argv [matching_argi + 2] == NULL)
+		matching_opt->handler (sd, matching_opt->opt.val,
+				       argv [matching_argi + 1], 1/*is_command*/);
+	      else
+		sim_io_eprintf (sd, "Command `%s' requires no more than one argument\n",
+				matching_opt->opt.name);
+	      break;
+	    case required_argument:
+	      if (argv [matching_argi + 1] == NULL)
+		sim_io_eprintf (sd, "Command `%s' requires an argument\n",
+				matching_opt->opt.name);
+	      else if (argv [matching_argi + 2] == NULL)
+		matching_opt->handler (sd, matching_opt->opt.val,
+				       argv [matching_argi + 1], 1/*is_command*/);
+	      else
+		sim_io_eprintf (sd, "Command `%s' requires only one argument\n",
+				matching_opt->opt.name);
+	    }
+	  return SIM_RC_OK;
+	}
     }
-
-  /* didn't find anything that matched */
+      
+  /* didn't find anything that remotly matched */
   return SIM_RC_FAIL;
 }
diff --git a/sim/common/sim-options.h b/sim/common/sim-options.h
index f6f4dde..586b91c 100644
--- a/sim/common/sim-options.h
+++ b/sim/common/sim-options.h
@@ -29,13 +29,14 @@ with this program; if not, write to the Free Software Foundation, Inc.,
    sim_open handles the large majority of them and it also parses the
    options when invoked by gdb [or any external program].
 
-   Per getopt: arg#2 is the option index; arg#3 is the option's
-   argument, NULL if optional and missing. */
+   arg#2 is the option index; arg#3 is the option's argument, NULL if
+   optional and missing; arg#4 is nonzero if being called as a
+   command. */
 
-typedef SIM_RC (OPTION_HANDLER) PARAMS ((SIM_DESC, int, char *));
+typedef SIM_RC (OPTION_HANDLER) PARAMS ((SIM_DESC, int, char *, int));
 
 /* Declare option handlers with a macro so it's usable on k&r systems.  */
-#define DECLARE_OPTION_HANDLER(fn) SIM_RC fn PARAMS ((SIM_DESC, int, char *))
+#define DECLARE_OPTION_HANDLER(fn) SIM_RC fn PARAMS ((SIM_DESC, int, char *, int))
 
 typedef struct {
   /* The long option information.  */
@@ -49,6 +50,12 @@ typedef struct {
   const char *doc;
   /* A function to process the option.  */
   OPTION_HANDLER *handler;
+  /* The documented name of the option.  If this is NULL, opt.name is
+     listed; otherwize this is listed as the name of the option.
+     Ex: given the options --set-pc, set-sp, et.al. the first option
+     would have doc_opt set to `--set-REGNAME' with the others set to
+     "".  Only --set-REGNAME would then be listed.   */
+  const char *doc_name;
 } OPTION;
 
 /* All options that don't have a short form equivalent begin with this for
diff --git a/sim/common/sim-trace.c b/sim/common/sim-trace.c
index f617783..944a781 100644
--- a/sim/common/sim-trace.c
+++ b/sim/common/sim-trace.c
@@ -23,6 +23,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "sim-options.h"
 #include "bfd.h"
 
+#include "sim-assert.h"
+
 #ifdef HAVE_STRING_H
 #include <string.h>
 #else
@@ -69,44 +71,46 @@ enum {
 
 static const OPTION trace_options[] =
 {
-  { {"trace", no_argument, NULL, 't'},
-      't', NULL, "Perform tracing",
+  { {"trace", optional_argument, NULL, 't'},
+      't', "on|off", "Perform tracing",
       trace_option_handler },
-  { {"trace-insn", no_argument, NULL, OPTION_TRACE_INSN},
-      '\0', NULL, "Perform instruction tracing",
+  { {"trace-insn", optional_argument, NULL, OPTION_TRACE_INSN},
+      '\0', "on|off", "Perform instruction tracing",
       trace_option_handler },
-  { {"trace-decode", no_argument, NULL, OPTION_TRACE_DECODE},
-      '\0', NULL, "Perform instruction decoding tracing",
+  { {"trace-decode", optional_argument, NULL, OPTION_TRACE_DECODE},
+      '\0', "on|off", "Perform instruction decoding tracing",
       trace_option_handler },
-  { {"trace-extract", no_argument, NULL, OPTION_TRACE_EXTRACT},
-      '\0', NULL, "Perform instruction extraction tracing",
+  { {"trace-extract", optional_argument, NULL, OPTION_TRACE_EXTRACT},
+      '\0', "on|off", "Perform instruction extraction tracing",
       trace_option_handler },
-  { {"trace-linenum", no_argument, NULL, OPTION_TRACE_LINENUM},
-      '\0', NULL, "Perform line number tracing (implies --trace-insn)",
+  { {"trace-linenum", optional_argument, NULL, OPTION_TRACE_LINENUM},
+      '\0', "on|off", "Perform line number tracing (implies --trace-insn)",
       trace_option_handler },
-  { {"trace-memory", no_argument, NULL, OPTION_TRACE_MEMORY},
-      '\0', NULL, "Perform memory tracing",
+  { {"trace-memory", optional_argument, NULL, OPTION_TRACE_MEMORY},
+      '\0', "on|off", "Perform memory tracing",
       trace_option_handler },
-  { {"trace-model", no_argument, NULL, OPTION_TRACE_MODEL},
-      '\0', NULL, "Perform model tracing",
+  { {"trace-model", optional_argument, NULL, OPTION_TRACE_MODEL},
+      '\0', "on|off", "Perform model tracing",
       trace_option_handler },
-  { {"trace-alu", no_argument, NULL, OPTION_TRACE_ALU},
-      '\0', NULL, "Perform ALU tracing",
+  { {"trace-alu", optional_argument, NULL, OPTION_TRACE_ALU},
+      '\0', "on|off", "Perform ALU tracing",
       trace_option_handler },
-  { {"trace-core", no_argument, NULL, OPTION_TRACE_CORE},
-      '\0', NULL, "Perform CORE tracing",
+#if (WITH_CORE)
+  { {"trace-core", optional_argument, NULL, OPTION_TRACE_CORE},
+      '\0', "on|off", "Perform CORE tracing",
       trace_option_handler },
-  { {"trace-events", no_argument, NULL, OPTION_TRACE_EVENTS},
-      '\0', NULL, "Perform EVENTS tracing",
+#endif
+  { {"trace-events", optional_argument, NULL, OPTION_TRACE_EVENTS},
+      '\0', "on|off", "Perform EVENTS tracing",
       trace_option_handler },
-  { {"trace-fpu", no_argument, NULL, OPTION_TRACE_FPU},
-      '\0', NULL, "Perform FPU tracing",
+  { {"trace-fpu", optional_argument, NULL, OPTION_TRACE_FPU},
+      '\0', "on|off", "Perform FPU tracing",
       trace_option_handler },
-  { {"trace-branch", no_argument, NULL, OPTION_TRACE_BRANCH},
-      '\0', NULL, "Perform branch tracing",
+  { {"trace-branch", optional_argument, NULL, OPTION_TRACE_BRANCH},
+      '\0', "on|off", "Perform branch tracing",
       trace_option_handler },
-  { {"trace-semantics", no_argument, NULL, OPTION_TRACE_SEMANTICS},
-      '\0', NULL, "Perform ALU, FPU, and MEMORY tracing",
+  { {"trace-semantics", optional_argument, NULL, OPTION_TRACE_SEMANTICS},
+      '\0', "on|off", "Perform ALU, FPU, MEMORY, and BRANCH tracing",
       trace_option_handler },
   { {"trace-file", required_argument, NULL, OPTION_TRACE_FILE},
       '\0', "FILE NAME", "Specify tracing output file",
@@ -114,13 +118,69 @@ static const OPTION trace_options[] =
   { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
 };
 
+
+/* Set FIRST_TRACE .. LAST_TRACE according to arg.  At least
+   FIRST_TRACE is always set */
+
 static SIM_RC
-trace_option_handler (sd, opt, arg)
+set_trace_options (sd, name, first_trace, last_trace, arg)
+     SIM_DESC sd;
+     const char *name;
+     int first_trace;
+     int last_trace;
+     const char *arg;
+{
+  int trace_nr;
+  int cpu_nr;
+  int trace_val = 1;
+  if (arg != NULL)
+    {
+      if (strcmp (arg, "yes") == 0
+	  || strcmp (arg, "on") == 0
+	  || strcmp (arg, "1") == 0)
+	trace_val = 1;
+      else if (strcmp (arg, "no") == 0
+	       || strcmp (arg, "off") == 0
+	       || strcmp (arg, "0") == 0)
+	trace_val = 0;
+      else
+	{
+	  sim_io_eprintf (sd, "Argument `%s' for `--trace%s' invalid, one of `on', `off', `yes', `no' expected\n", arg, name);
+	  return SIM_RC_FAIL;
+	}
+    }
+  trace_nr = first_trace;
+  do
+    {
+      switch (trace_nr)
+	{
+#if (WITH_CORE)
+	case TRACE_CORE_IDX:
+	  STATE_CORE(sd)->trace = trace_val;
+	  break;
+#endif
+	case TRACE_EVENTS_IDX:
+	  STATE_EVENTS(sd)->trace = trace_val;
+	  break;
+	}
+      for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
+	{
+	  CPU_TRACE_FLAGS (STATE_CPU (sd, cpu_nr))[trace_nr] = trace_val;
+	}
+    }
+  while (++trace_nr < last_trace);
+  return SIM_RC_OK;
+}
+
+
+static SIM_RC
+trace_option_handler (sd, opt, arg, is_command)
      SIM_DESC sd;
      int opt;
      char *arg;
+     int is_command;
 {
-  int i,n;
+  int n;
 
   switch (opt)
     {
@@ -128,123 +188,104 @@ trace_option_handler (sd, opt, arg)
       if (! WITH_TRACE)
 	sim_io_eprintf (sd, "Tracing not compiled in, `-t' ignored\n");
       else
-	{
-	  for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	    for (i = 0; i < MAX_TRACE_VALUES; ++i)
-	      CPU_TRACE_FLAGS (STATE_CPU (sd, n))[i] = 1;
-	  STATE_CORE(sd)->trace = 1;
-	  STATE_EVENTS(sd)->trace = 1;
-	}
+	return set_trace_options (sd, "trace", 0, MAX_TRACE_VALUES, arg);
       break;
 
     case OPTION_TRACE_INSN :
       if (WITH_TRACE_INSN_P)
-	for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	  CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_INSN_IDX] = 1;
+	return set_trace_options (sd, "-insn", TRACE_INSN_IDX, -1, arg);
       else
 	sim_io_eprintf (sd, "Instruction tracing not compiled in, `--trace-insn' ignored\n");
       break;
 
     case OPTION_TRACE_DECODE :
       if (WITH_TRACE_DECODE_P)
-	for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	  CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_DECODE_IDX] = 1;
+	return set_trace_options (sd, "-decode", TRACE_DECODE_IDX, -1, arg);
       else
 	sim_io_eprintf (sd, "Decode tracing not compiled in, `--trace-decode' ignored\n");
       break;
 
     case OPTION_TRACE_EXTRACT :
       if (WITH_TRACE_EXTRACT_P)
-	for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	  CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_EXTRACT_IDX] = 1;
+	return set_trace_options (sd, "-extract", TRACE_EXTRACT_IDX, -1, arg);
       else
 	sim_io_eprintf (sd, "Extract tracing not compiled in, `--trace-extract' ignored\n");
       break;
 
     case OPTION_TRACE_LINENUM :
       if (WITH_TRACE_LINENUM_P && WITH_TRACE_INSN_P)
-	for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	  {
-	    CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_LINENUM_IDX] = 1;
-	    CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_INSN_IDX] = 1;
-	  }
+	{
+	  if (set_trace_options (sd, "-linenum", TRACE_LINENUM_IDX, -1, arg) != SIM_RC_OK
+	      || set_trace_options (sd, "-linenum", TRACE_INSN_IDX, -1, arg) != SIM_RC_OK)
+	    return SIM_RC_FAIL;
+	}
       else
 	sim_io_eprintf (sd, "Line number or instruction tracing not compiled in, `--trace-linenum' ignored\n");
       break;
 
     case OPTION_TRACE_MEMORY :
       if (WITH_TRACE_MEMORY_P)
-	for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	  CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_MEMORY_IDX] = 1;
+	return set_trace_options (sd, "-memory", TRACE_MEMORY_IDX, -1, arg);
       else
 	sim_io_eprintf (sd, "Memory tracing not compiled in, `--trace-memory' ignored\n");
       break;
 
     case OPTION_TRACE_MODEL :
       if (WITH_TRACE_MODEL_P)
-	for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	  CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_MODEL_IDX] = 1;
+	return set_trace_options (sd, "-model", TRACE_MODEL_IDX, -1, arg);
       else
 	sim_io_eprintf (sd, "Model tracing not compiled in, `--trace-model' ignored\n");
       break;
 
     case OPTION_TRACE_ALU :
       if (WITH_TRACE_ALU_P)
-	for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	  CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_ALU_IDX] = 1;
+	return set_trace_options (sd, "-alu", TRACE_ALU_IDX, -1, arg);
       else
 	sim_io_eprintf (sd, "ALU tracing not compiled in, `--trace-alu' ignored\n");
       break;
 
     case OPTION_TRACE_CORE :
       if (WITH_TRACE_CORE_P)
-	{
-	  for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	    CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_CORE_IDX] = 1;
-	  STATE_CORE(sd)->trace = 1;
-	}
+	return set_trace_options (sd, "-core", TRACE_CORE_IDX, -1, arg);
       else
 	sim_io_eprintf (sd, "CORE tracing not compiled in, `--trace-core' ignored\n");
       break;
 
     case OPTION_TRACE_EVENTS :
       if (WITH_TRACE_EVENTS_P)
-	{
-	  for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	    CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_EVENTS_IDX] = 1;
-	  STATE_EVENTS(sd)->trace = 1;
-	}
+	return set_trace_options (sd, "-events", TRACE_EVENTS_IDX, -1, arg);
       else
 	sim_io_eprintf (sd, "EVENTS tracing not compiled in, `--trace-events' ignored\n");
       break;
 
     case OPTION_TRACE_FPU :
       if (WITH_TRACE_FPU_P)
-	for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	  CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_FPU_IDX] = 1;
+	return set_trace_options (sd, "-fpu", TRACE_FPU_IDX, -1, arg);
       else
 	sim_io_eprintf (sd, "FPU tracing not compiled in, `--trace-fpu' ignored\n");
       break;
 
     case OPTION_TRACE_BRANCH :
       if (WITH_TRACE_BRANCH_P)
-	for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	  CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_FPU_IDX] = 1;
+	return set_trace_options (sd, "-branch", TRACE_BRANCH_IDX, -1, arg);
       else
 	sim_io_eprintf (sd, "Branch tracing not compiled in, `--trace-branch' ignored\n");
       break;
 
     case OPTION_TRACE_SEMANTICS :
-      if (WITH_TRACE_ALU_P && WITH_TRACE_FPU_P && WITH_TRACE_MEMORY_P)
-	for (n = 0; n < MAX_NR_PROCESSORS; ++n)
-	  {
-	    CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_ALU_IDX] = 1;
-	    CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_FPU_IDX] = 1;
-	    CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_MEMORY_IDX] = 1;
-	    CPU_TRACE_FLAGS (STATE_CPU (sd, n))[TRACE_BRANCH_IDX] = 1;
-	  }
+      if (WITH_TRACE_ALU_P
+	  && WITH_TRACE_FPU_P
+	  && WITH_TRACE_MEMORY_P
+	  && WITH_TRACE_BRANCH_P)
+	{
+	  if (set_trace_options (sd, "-semantics", TRACE_ALU_IDX, -1, arg) != SIM_RC_OK
+	      || set_trace_options (sd, "-semantics", TRACE_FPU_IDX, -1, arg) != SIM_RC_OK
+	      || set_trace_options (sd, "-semantics", TRACE_MEMORY_IDX, -1, arg) != SIM_RC_OK
+	      || set_trace_options (sd, "-semantics", TRACE_BRANCH_IDX, -1, arg) != SIM_RC_OK)
+	    return SIM_RC_FAIL;
+	}
       else
-	sim_io_eprintf (sd, "Alu, fpu, and/or memory tracing not compiled in, `--trace-semantics' ignored\n");
+	sim_io_eprintf (sd, "Alu, fpu, memory, and/or branch tracing not compiled in, `--trace-semantics' ignored\n");
       break;
 
     case OPTION_TRACE_FILE :
@@ -275,6 +316,8 @@ trace_install (SIM_DESC sd)
 {
   int i;
 
+  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
+
   sim_add_option_table (sd, trace_options);
   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
     memset (CPU_TRACE_DATA (STATE_CPU (sd, i)), 0,
diff --git a/sim/common/sim-watch.c b/sim/common/sim-watch.c
new file mode 100644
index 0000000..9a0b1bc
--- /dev/null
+++ b/sim/common/sim-watch.c
@@ -0,0 +1,295 @@
+/* Mips simulator watchpoint support.
+   Copyright (C) 1997 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 2, 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, write to the Free Software Foundation, Inc.,
+59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#include "sim-main.h"
+#include "sim-options.h"
+
+#include "sim-assert.h"
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#include <signal.h>
+
+static DECLARE_OPTION_HANDLER (watch_option_handler);
+
+enum {
+  OPTION_WATCH_DELETE                      = OPTION_START,
+
+  OPTION_WATCH_PC,
+  OPTION_WATCH_CLOCK,
+  OPTION_WATCH_CYCLES,
+
+  OPTION_ACTION_PC,
+  OPTION_ACTION_CLOCK,
+  OPTION_ACTION_CYCLES,
+};
+
+
+static void
+delete_watchpoint (SIM_DESC sd, watchpoint_type type)
+{
+  sim_watch_point *point = &STATE_WATCHPOINTS (sd)->points[type];
+  if (point->event != NULL)
+    sim_events_deschedule (sd, point->event);
+  point->action = invalid_watchpoint_action;
+  point->event = NULL;
+}
+
+
+static sim_event_handler handle_watchpoint;
+
+static SIM_RC
+schedule_watchpoint (SIM_DESC sd,
+		     watchpoint_type type,
+		     unsigned long arg,
+		     int is_command)
+{
+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
+  sim_watch_point *point = &watch->points[type];
+  if (point->event != NULL)
+    delete_watchpoint (sd, type);
+  point->arg = arg;
+  if (point->action == invalid_watchpoint_action)
+    point->action = break_watchpoint_action;
+  if (is_command)
+    switch (type)
+      {
+      case pc_watchpoint:
+	point->event = sim_events_watch_sim (sd, watch->pc, watch->sizeof_pc,
+					     0/* host-endian */,
+					     point->arg, point->arg, /* PC == arg? */
+					     handle_watchpoint,
+					     point);
+	return SIM_RC_OK;
+      case clock_watchpoint:
+	point->event = sim_events_watch_clock (sd,
+					       point->arg, /* ms time */
+					       handle_watchpoint,
+					       point);
+	return SIM_RC_OK;
+      case cycles_watchpoint:
+	point->event = sim_events_schedule (sd, point->arg, /* time */
+					    handle_watchpoint,
+					    point);
+	return SIM_RC_OK;
+      default:
+	sim_engine_abort (sd, NULL, NULL_CIA,
+			  "handle_watchpoint - internal error - bad switch");
+	return SIM_RC_FAIL;
+      }
+  return SIM_RC_OK;
+}
+
+
+static void
+handle_watchpoint (SIM_DESC sd, void *data)
+{
+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
+  sim_watch_point *point = data;
+  watchpoint_type type = point - watch->points;
+
+  switch (point->action)
+    {
+
+    case break_watchpoint_action:
+      point->event = NULL; /* gone */
+      sim_engine_halt (sd, NULL, NULL, NULL_CIA, sim_stopped, SIGINT);
+      break;
+
+    case n_interrupt_watchpoint_action:
+      /* First reschedule this event */
+      schedule_watchpoint (sd, type, point->arg, 1/*is-command*/);
+      /* FALL-THROUGH */
+
+    case interrupt_watchpoint_action:
+      watch->interrupt_handler (sd, NULL);
+      break;
+
+    default:
+	  sim_engine_abort (sd, NULL, NULL_CIA,
+			    "handle_watchpoint - internal error - bad switch");
+
+    }
+}
+
+
+static SIM_RC
+action_watchpoint (SIM_DESC sd, watchpoint_type type, const char *arg)
+{
+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
+  sim_watch_point *point = &watch->points[type];
+  if (strcmp (arg, "break") == NULL)
+    {
+      point->action = break_watchpoint_action;
+    }
+  else if (strcmp (arg, "int") == NULL)
+    {
+      if (watch->interrupt_handler == NULL)
+	{
+	  sim_io_eprintf (sd, "This simulator does not support int watchpoints\n");
+	  return SIM_RC_FAIL;
+	}
+      point->action = interrupt_watchpoint_action;
+    }
+  else if (strcmp (arg, "+int") == 0)
+    {
+      if (watch->interrupt_handler == NULL)
+	{
+	  sim_io_eprintf (sd, "This simulator does not support int watchpoints\n");
+	  return SIM_RC_FAIL;
+	}
+      point->action = n_interrupt_watchpoint_action;
+    }
+  else
+    {
+      sim_io_eprintf (sd, "Interrupts other than `int' currently unsuported\n");
+      return SIM_RC_FAIL;
+    }
+  return SIM_RC_OK;
+}
+
+
+static const OPTION watch_options[] =
+{
+  { {"watch-delete", required_argument, NULL, OPTION_WATCH_DELETE },
+      '\0', "all|pc|cycles|clock", "Delete a watchpoint",
+      watch_option_handler },
+
+  { {"watch-pc", required_argument, NULL, OPTION_WATCH_PC },
+      '\0', "VALUE", "Watch the PC (break)",
+      watch_option_handler },
+  { {"watch-clock", required_argument, NULL, OPTION_WATCH_CLOCK },
+      '\0', "TIME-IN-MS", "Watch the clock (break)",
+      watch_option_handler },
+  { {"watch-cycles", required_argument, NULL, OPTION_WATCH_CYCLES },
+      '\0', "CYCLES", "Watch the cycles (break)",
+      watch_option_handler },
+
+  { {"action-pc", required_argument, NULL, OPTION_ACTION_PC },
+      '\0', "break|int|+int", "Action taken by PC watchpoint",
+      watch_option_handler },
+  { {"action-clock", required_argument, NULL, OPTION_ACTION_CLOCK },
+      '\0', "break|int|+int", "Action taken by CLOCK watchpoint",
+      watch_option_handler },
+  { {"action-cycles", required_argument, NULL, OPTION_ACTION_CYCLES },
+      '\0', "break|int|+int", "Action taken by CYCLES watchpoint",
+      watch_option_handler },
+
+  { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
+};
+
+
+static SIM_RC
+watch_option_handler (sd, opt, arg, is_command)
+     SIM_DESC sd;
+     int opt;
+     char *arg;
+     int is_command;
+{
+  switch (opt)
+    {
+
+    case OPTION_WATCH_DELETE:
+      if (strcmp (arg, "all") == 0
+	  || strcmp (arg, "pc") == 0)
+	{
+	  delete_watchpoint (sd, pc_watchpoint);
+	  return SIM_RC_OK;
+	}
+      if (strcmp (arg, "all") == 0
+	  || strcmp (arg, "clock") == 0)
+	{
+	  delete_watchpoint (sd, clock_watchpoint);
+	  return SIM_RC_OK;
+	}
+      if (strcmp (arg, "all") == 0
+	  || strcmp (arg, "cycles") == 0)
+	{
+	  delete_watchpoint (sd, cycles_watchpoint);
+	  return SIM_RC_OK;
+	}
+      sim_io_eprintf (sd, "Unknown watchpoint type `%s'\n", arg);
+      return SIM_RC_FAIL;
+
+    case OPTION_WATCH_PC:
+      if (STATE_WATCHPOINTS (sd)->pc == NULL)
+	{
+	  sim_io_eprintf (sd, "PC watchpoints are not supported for this simulator\n");
+	  return SIM_RC_FAIL;
+	}
+      return schedule_watchpoint (sd, pc_watchpoint, strtoul (arg, NULL, 0), is_command);
+
+    case OPTION_WATCH_CLOCK:
+      return schedule_watchpoint (sd, clock_watchpoint, strtoul (arg, NULL, 0), is_command);
+
+    case OPTION_WATCH_CYCLES:
+      return schedule_watchpoint (sd, cycles_watchpoint, strtoul (arg, NULL, 0), is_command);
+
+    case OPTION_ACTION_PC:
+      return action_watchpoint (sd, cycles_watchpoint, arg);
+
+    case OPTION_ACTION_CLOCK:
+      return action_watchpoint (sd, cycles_watchpoint, arg);
+
+    case OPTION_ACTION_CYCLES:
+      return action_watchpoint (sd, cycles_watchpoint, arg);
+
+
+    default:
+      sim_io_eprintf (sd, "Unknown watch option %d\n", opt);
+      return SIM_RC_FAIL;
+
+    }
+
+}
+
+static SIM_RC
+sim_watchpoint_init (SIM_DESC sd)
+{
+  /* schedule any watchpoints enabled by command line options */
+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
+  watchpoint_type type;
+  for (type = 0; type < nr_watchpoint_types; type++)
+    {
+      if (watch->points[type].action != invalid_watchpoint_action)
+	schedule_watchpoint (sd, type, watch->points[type].arg, 1/*is-command*/);
+    }
+  return SIM_RC_OK;
+}
+
+
+SIM_RC
+sim_watchpoint_install (SIM_DESC sd)
+{
+  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
+  sim_add_option_table (sd, watch_options);
+  sim_module_add_init_fn (sd, sim_watchpoint_init);
+  return SIM_RC_OK;
+}
diff --git a/sim/common/sim-watch.h b/sim/common/sim-watch.h
new file mode 100644
index 0000000..b101ebb
--- /dev/null
+++ b/sim/common/sim-watch.h
@@ -0,0 +1,67 @@
+/* Simulator watchpoint support.
+   Copyright (C) 1997 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 2, 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, write to the Free Software Foundation, Inc.,
+59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+#ifndef SIM_WATCH_H
+#define SIM_WATCH_H
+
+typedef enum {
+  pc_watchpoint,
+  clock_watchpoint,
+  cycles_watchpoint,
+  nr_watchpoint_types,
+} watchpoint_type;
+
+typedef enum {
+  invalid_watchpoint_action,
+  n_interrupt_watchpoint_action,
+  interrupt_watchpoint_action,
+  break_watchpoint_action,
+} watchpoint_action;
+
+typedef struct _sim_watch_point {
+  watchpoint_action action;
+  long arg;
+  sim_event *event;
+} sim_watch_point;
+
+
+typedef struct _sim_watchpoints {
+
+  /* Pointer into the host's data structures specifying the
+     address/size of the program-counter */
+  /* FIXME: In the future this shall be generalized so that any of the
+     N processors M registers can be watched */
+  void *pc;
+  int sizeof_pc;
+
+  /* Pointer to the handler for interrupt watchpoints */
+  /* FIXME: can this be done better? */
+  sim_event_handler *interrupt_handler;
+
+  /* suported watchpoints */
+  sim_watch_point points[nr_watchpoint_types];
+
+} sim_watchpoints;
+
+/* Watch install handler.  */
+MODULE_INSTALL_FN sim_watchpoint_install;
+
+#endif /* SIM_WATCH_H */