Really remove tic30-aout support

[deliverable/binutils-gdb.git] / sim / common / sim-watch.c

diff --git a/sim/common/sim-watch.c b/sim/common/sim-watch.c
index 9a0b1bc098899078bd3635f34522e2862805412d..f9df155559a1022b9e53681af6461b6af576223d 100644 (file)
--- a/sim/common/sim-watch.c
+++ b/sim/common/sim-watch.c
@@ -1,28 +1,31 @@
-/* Mips simulator watchpoint support.
-   Copyright (C) 1997 Free Software Foundation, Inc.
+/* Generic simulator watchpoint support.
+   Copyright (C) 1997-2020 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
    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.
+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.
 
 
 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.  */
+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 "config.h"

 #include "sim-main.h"
 #include "sim-options.h"
 
 #include "sim-assert.h"
 
 #include "sim-main.h"
 #include "sim-options.h"
 
 #include "sim-assert.h"
 

+#include <ctype.h>
+#include <stdio.h>
+

 #ifdef HAVE_STRING_H
 #include <string.h>
 #else
 #ifdef HAVE_STRING_H
 #include <string.h>
 #else


@@ -35,261 +38,423 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <stdlib.h>
 #endif
 
 #include <stdlib.h>
 #endif
 

-#include <signal.h>
-
-static DECLARE_OPTION_HANDLER (watch_option_handler);
-

 enum {
   OPTION_WATCH_DELETE                      = OPTION_START,
 
 enum {
   OPTION_WATCH_DELETE                      = OPTION_START,
 

-  OPTION_WATCH_PC,
+  OPTION_WATCH_INFO,

   OPTION_WATCH_CLOCK,
   OPTION_WATCH_CYCLES,
   OPTION_WATCH_CLOCK,
   OPTION_WATCH_CYCLES,

+  OPTION_WATCH_PC,

 
 

-  OPTION_ACTION_PC,
-  OPTION_ACTION_CLOCK,
-  OPTION_ACTION_CYCLES,
+  OPTION_WATCH_OP,

 };
 
 
 };
 
 

-static void
-delete_watchpoint (SIM_DESC sd, watchpoint_type type)
+/* Break an option number into its op/int-nr */
+static watchpoint_type
+option_to_type (SIM_DESC sd,
+               int option)

 {
 {

-  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;
+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
+  watchpoint_type type = ((option - OPTION_WATCH_OP)
+                         / (watch->nr_interrupts + 1));
+  SIM_ASSERT (type >= 0 && type < nr_watchpoint_types);
+  return type;

 }
 
 }
 

+static int
+option_to_interrupt_nr (SIM_DESC sd,
+                       int option)
+{
+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
+  int interrupt_nr = ((option - OPTION_WATCH_OP)
+                     % (watch->nr_interrupts + 1));
+  return interrupt_nr;
+}

 
 

-static sim_event_handler handle_watchpoint;
-
-static SIM_RC
-schedule_watchpoint (SIM_DESC sd,
-                    watchpoint_type type,
-                    unsigned long arg,
-                    int is_command)
+static int
+type_to_option (SIM_DESC sd,
+               watchpoint_type type,
+               int interrupt_nr)

 {
   sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
 {
   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;
+  return ((type * (watch->nr_interrupts + 1))
+         + interrupt_nr
+         + OPTION_WATCH_OP);

 }
 
 
 }
 
 

-static void
-handle_watchpoint (SIM_DESC sd, void *data)
+/* Delete one or more watchpoints.  Fail if no watchpoints were found */
+
+static SIM_RC
+do_watchpoint_delete (SIM_DESC sd,
+                     int ident,
+                     watchpoint_type type)

 {
   sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
 {
   sim_watchpoints *watch = STATE_WATCHPOINTS (sd);

-  sim_watch_point *point = data;
-  watchpoint_type type = point - watch->points;
-
-  switch (point->action)
+  sim_watch_point **entry = &watch->points;
+  SIM_RC status = SIM_RC_FAIL;
+  while ((*entry) != NULL)

     {
     {

+      if ((*entry)->ident == ident
+         || (*entry)->type == type)
+       {
+         sim_watch_point *dead = (*entry);
+         (*entry) = (*entry)->next;
+         sim_events_deschedule (sd, dead->event);
+         free (dead);
+         status = SIM_RC_OK;
+       }
+      else
+       entry = &(*entry)->next;
+    }
+  return status;
+}

 
 

-    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 */
+static const char *
+watchpoint_type_to_str (SIM_DESC sd,
+                       watchpoint_type type)
+{
+  switch (type)
+    {
+    case  pc_watchpoint:
+      return "pc";
+    case clock_watchpoint:
+      return "clock";
+    case cycles_watchpoint:
+      return "cycles";
+    case invalid_watchpoint:
+    case nr_watchpoint_types:
+      return "(invalid-type)";
+    }
+  return NULL;
+}

 
 

-    case interrupt_watchpoint_action:
-      watch->interrupt_handler (sd, NULL);
-      break;
+static const char *
+interrupt_nr_to_str (SIM_DESC sd,
+                    int interrupt_nr)
+{
+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
+  if (interrupt_nr < 0)
+    return "(invalid-interrupt)";
+  else if (interrupt_nr >= watch->nr_interrupts)
+    return "breakpoint";
+  else
+    return watch->interrupt_names[interrupt_nr];
+}

 
 

-    default:
-         sim_engine_abort (sd, NULL, NULL_CIA,
-                           "handle_watchpoint - internal error - bad switch");

 
 

+static void
+do_watchpoint_info (SIM_DESC sd)
+{
+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
+  sim_watch_point *point;
+  sim_io_printf (sd, "Watchpoints:\n");
+  for (point = watch->points; point != NULL; point = point->next)
+    {
+      sim_io_printf (sd, "%3d: watch %s %s ",
+                    point->ident,
+                    watchpoint_type_to_str (sd, point->type),
+                    interrupt_nr_to_str (sd, point->interrupt_nr));
+      if (point->is_periodic)
+       sim_io_printf (sd, "+");
+      if (!point->is_within)
+       sim_io_printf (sd, "!");
+      sim_io_printf (sd, "0x%lx", point->arg0);
+      if (point->arg1 != point->arg0)
+       sim_io_printf (sd, ",0x%lx", point->arg1);
+      sim_io_printf (sd, "\n");

     }
 }
 
 
     }
 }
 
 

+
+static sim_event_handler handle_watchpoint;
+

 static SIM_RC
 static SIM_RC

-action_watchpoint (SIM_DESC sd, watchpoint_type type, const char *arg)
+schedule_watchpoint (SIM_DESC sd,
+                    sim_watch_point *point)

 {
   sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
 {
   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)
+  switch (point->type)

     {
     {

-      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");
+    case pc_watchpoint:
+      point->event = sim_events_watch_sim (sd,
+                                          watch->pc,
+                                          watch->sizeof_pc,
+                                          0/* host-endian */,
+                                          point->is_within,
+                                          point->arg0, point->arg1,
+                                          /* PC in arg0..arg1 */
+                                          handle_watchpoint,
+                                          point);
+      return SIM_RC_OK;
+    case clock_watchpoint:
+      point->event = sim_events_watch_clock (sd,
+                                            point->arg0, /* ms time */
+                                            handle_watchpoint,
+                                            point);
+      return SIM_RC_OK;
+    case cycles_watchpoint:
+      point->event = sim_events_schedule (sd,
+                                         point->arg0, /* 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;
 }
 
 
       return SIM_RC_FAIL;
     }
   return SIM_RC_OK;
 }
 
 

-static const OPTION watch_options[] =
+static void
+handle_watchpoint (SIM_DESC sd, void *data)

 {
 {

-  { {"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 }
-};
+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
+  sim_watch_point *point = (sim_watch_point *) data;
+  int interrupt_nr = point->interrupt_nr;
+
+  if (point->is_periodic)
+    /* reschedule this event before processing it */
+    schedule_watchpoint (sd, point);
+  else
+    do_watchpoint_delete (sd, point->ident, invalid_watchpoint);
+
+  if (point->interrupt_nr == watch->nr_interrupts)
+    sim_engine_halt (sd, NULL, NULL, NULL_CIA, sim_stopped, SIM_SIGINT);
+  else
+    watch->interrupt_handler (sd, &watch->interrupt_names[interrupt_nr]);
+}

 
 
 static SIM_RC
 
 
 static SIM_RC

-watch_option_handler (sd, opt, arg, is_command)
-     SIM_DESC sd;
-     int opt;
-     char *arg;
-     int is_command;
+do_watchpoint_create (SIM_DESC sd,
+                     watchpoint_type type,
+                     int opt,
+                     char *arg)

 {
 {

-  switch (opt)
+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
+  sim_watch_point **point;
+
+  /* create the watchpoint */
+  point = &watch->points;
+  while ((*point) != NULL)
+    point = &(*point)->next;
+  (*point) = ZALLOC (sim_watch_point);
+
+  /* fill in the details */
+  (*point)->ident = ++(watch->last_point_nr);
+  (*point)->type = option_to_type (sd, opt);
+  (*point)->interrupt_nr = option_to_interrupt_nr (sd, opt);
+  /* prefixes to arg - +== periodic, !==not or outside */
+  (*point)->is_within = 1;
+  while (1)

     {
     {

+      if (arg[0] == '+')
+       (*point)->is_periodic = 1;
+      else if (arg[0] == '!')
+       (*point)->is_within = 0;
+      else
+       break;
+      arg++;
+    }

 
 

-    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);
+  (*point)->arg0 = strtoul (arg, &arg, 0);
+  if (arg[0] == ',')
+    (*point)->arg0 = strtoul (arg, NULL, 0);
+  else
+    (*point)->arg1 = (*point)->arg0;

 
 

-    case OPTION_WATCH_CLOCK:
-      return schedule_watchpoint (sd, clock_watchpoint, strtoul (arg, NULL, 0), is_command);
+  /* schedule it */
+  schedule_watchpoint (sd, (*point));

 
 

-    case OPTION_WATCH_CYCLES:
-      return schedule_watchpoint (sd, cycles_watchpoint, strtoul (arg, NULL, 0), is_command);
+  return SIM_RC_OK;
+}

 
 

-    case OPTION_ACTION_PC:
-      return action_watchpoint (sd, cycles_watchpoint, arg);

 
 

-    case OPTION_ACTION_CLOCK:
-      return action_watchpoint (sd, cycles_watchpoint, arg);
+static SIM_RC
+watchpoint_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,
+                          char *arg, int is_command)
+{
+  if (opt >= OPTION_WATCH_OP)
+    return do_watchpoint_create (sd, clock_watchpoint, opt, arg);
+  else
+    switch (opt)
+      {

 
 

-    case OPTION_ACTION_CYCLES:
-      return action_watchpoint (sd, cycles_watchpoint, arg);
+      case OPTION_WATCH_DELETE:
+       if (isdigit ((int) arg[0]))
+         {
+           int ident = strtol (arg, NULL, 0);
+           if (do_watchpoint_delete (sd, ident, invalid_watchpoint)
+               != SIM_RC_OK)
+             {
+               sim_io_eprintf (sd, "Watchpoint %d not found\n", ident);
+               return SIM_RC_FAIL;
+             }
+           return SIM_RC_OK;
+         }
+       else if (strcasecmp (arg, "all") == 0)
+         {
+           watchpoint_type type;
+           for (type = invalid_watchpoint + 1;
+                type < nr_watchpoint_types;
+                type++)
+             {
+               do_watchpoint_delete (sd, 0, type);
+             }
+           return SIM_RC_OK;
+         }
+       else if (strcasecmp (arg, "pc") == 0)
+         {
+           if (do_watchpoint_delete (sd, 0, pc_watchpoint)
+               != SIM_RC_OK)
+             {
+               sim_io_eprintf (sd, "No PC watchpoints found\n");
+               return SIM_RC_FAIL;
+             }
+           return SIM_RC_OK;
+         }
+       else if (strcasecmp (arg, "clock") == 0)
+         {
+           if (do_watchpoint_delete (sd, 0, clock_watchpoint) != SIM_RC_OK)
+             {
+               sim_io_eprintf (sd, "No CLOCK watchpoints found\n");
+               return SIM_RC_FAIL;
+             }
+           return SIM_RC_OK;
+         }
+       else if (strcasecmp (arg, "cycles") == 0)
+         {
+           if (do_watchpoint_delete (sd, 0, cycles_watchpoint) != SIM_RC_OK)
+             {
+               sim_io_eprintf (sd, "No CYCLES watchpoints found\n");
+               return SIM_RC_FAIL;
+             }
+           return SIM_RC_OK;
+         }
+       sim_io_eprintf (sd, "Unknown watchpoint type `%s'\n", arg);
+       return SIM_RC_FAIL;

 
 

+      case OPTION_WATCH_INFO:
+       {
+         do_watchpoint_info (sd);
+         return SIM_RC_OK;
+       }

 
 

-    default:
-      sim_io_eprintf (sd, "Unknown watch option %d\n", opt);
-      return SIM_RC_FAIL;
+      default:
+       sim_io_eprintf (sd, "Unknown watch option %d\n", opt);
+       return SIM_RC_FAIL;

 
 

-    }
+      }

 
 }
 
 
 }
 

+

 static SIM_RC
 sim_watchpoint_init (SIM_DESC sd)
 {
 static SIM_RC
 sim_watchpoint_init (SIM_DESC sd)
 {

-  /* schedule any watchpoints enabled by command line options */

   sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
   sim_watchpoints *watch = STATE_WATCHPOINTS (sd);

-  watchpoint_type type;
-  for (type = 0; type < nr_watchpoint_types; type++)
+  sim_watch_point *point;
+  /* NOTE: Do not need to de-schedule any previous watchpoints as
+     sim-events has already done this */
+  /* schedule any watchpoints enabled by command line options */
+  for (point = watch->points; point != NULL; point = point->next)

     {
     {

-      if (watch->points[type].action != invalid_watchpoint_action)
-       schedule_watchpoint (sd, type, watch->points[type].arg, 1/*is-command*/);
+      schedule_watchpoint (sd, point);

     }
   return SIM_RC_OK;
 }
 
 
     }
   return SIM_RC_OK;
 }
 
 

+static const OPTION watchpoint_options[] =
+{
+  { {"watch-delete", required_argument, NULL, OPTION_WATCH_DELETE },
+      '\0', "IDENT|all|pc|cycles|clock", "Delete a watchpoint",
+      watchpoint_option_handler, NULL },
+
+  { {"watch-info", no_argument, NULL, OPTION_WATCH_INFO },
+      '\0', NULL, "List scheduled watchpoints",
+      watchpoint_option_handler, NULL },
+
+  { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL }
+};
+
+static const char *default_interrupt_names[] = { "int", 0, };
+
+
+

 SIM_RC
 sim_watchpoint_install (SIM_DESC sd)
 {
 SIM_RC
 sim_watchpoint_install (SIM_DESC sd)
 {

+  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);

   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);

-  sim_add_option_table (sd, watch_options);
+  /* the basic command set */

   sim_module_add_init_fn (sd, sim_watchpoint_init);
   sim_module_add_init_fn (sd, sim_watchpoint_init);

+  sim_add_option_table (sd, NULL, watchpoint_options);
+  /* fill in some details */
+  if (watch->interrupt_names == NULL)
+    watch->interrupt_names = default_interrupt_names;
+  watch->nr_interrupts = 0;
+  while (watch->interrupt_names[watch->nr_interrupts] != NULL)
+    watch->nr_interrupts++;
+  /* generate more advansed commands */
+  {
+    OPTION *int_options = NZALLOC (OPTION, 1 + (watch->nr_interrupts + 1) * nr_watchpoint_types);
+    int interrupt_nr;
+    for (interrupt_nr = 0; interrupt_nr <= watch->nr_interrupts; interrupt_nr++)
+      {
+       watchpoint_type type;
+       for (type = 0; type < nr_watchpoint_types; type++)
+         {
+           char *name;
+           int nr = interrupt_nr * nr_watchpoint_types + type;
+           OPTION *option = &int_options[nr];
+           if (asprintf (&name, "watch-%s-%s",
+                         watchpoint_type_to_str (sd, type),
+                         interrupt_nr_to_str (sd, interrupt_nr)) < 0)
+             return SIM_RC_FAIL;
+           option->opt.name = name;
+           option->opt.has_arg = required_argument;
+           option->opt.val = type_to_option (sd, type, interrupt_nr);
+           option->doc = "";
+           option->doc_name = "";
+           option->handler = watchpoint_option_handler;
+         }
+      }
+    /* adjust first few entries so that they contain real
+       documentation, the first entry includes a list of actions. */
+    {
+      const char *prefix =
+       "Watch the simulator, take ACTION in COUNT cycles (`+' for every COUNT cycles), ACTION is";
+      char *doc;
+      int len = strlen (prefix) + 1;
+      for (interrupt_nr = 0; interrupt_nr <= watch->nr_interrupts; interrupt_nr++)
+       len += strlen (interrupt_nr_to_str (sd, interrupt_nr)) + 1;
+      doc = NZALLOC (char, len);
+      strcpy (doc, prefix);
+      for (interrupt_nr = 0; interrupt_nr <= watch->nr_interrupts; interrupt_nr++)
+       {
+         strcat (doc, " ");
+         strcat (doc, interrupt_nr_to_str (sd, interrupt_nr));
+       }
+      int_options[0].doc_name = "watch-cycles-ACTION";
+      int_options[0].arg = "[+]COUNT";
+      int_options[0].doc = doc;
+    }
+    int_options[1].doc_name = "watch-pc-ACTION";
+    int_options[1].arg = "[!]ADDRESS";
+    int_options[1].doc =
+      "Watch the PC, take ACTION when matches ADDRESS (in range ADDRESS,ADDRESS), `!' negates test";
+    int_options[2].doc_name = "watch-clock-ACTION";
+    int_options[2].arg = "[+]MILLISECONDS";
+    int_options[2].doc =
+      "Watch the clock, take ACTION after MILLISECONDS (`+' for every MILLISECONDS)";
+
+    sim_add_option_table (sd, NULL, int_options);
+  }

   return SIM_RC_OK;
 }
   return SIM_RC_OK;
 }