URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [sim/] [common/] [sim-watch.c] - Blame information for rev 853

Go to most recent revision | Details | Compare with Previous | View Log


/* Generic simulator watchpoint support.
   Copyright (C) 1997, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   Contributed by Cygnus Support.
 
This file is part of GDB, the GNU debugger.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
#include "sim-main.h"
#include "sim-options.h"
 
#include "sim-assert.h"
 
#include <ctype.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
 
enum {
  OPTION_WATCH_DELETE                      = OPTION_START,
 
  OPTION_WATCH_INFO,
  OPTION_WATCH_CLOCK,
  OPTION_WATCH_CYCLES,
  OPTION_WATCH_PC,
 
  OPTION_WATCH_OP,
};
 
 
/* Break an option number into its op/int-nr */
static watchpoint_type
option_to_type (SIM_DESC sd,
                int option)
{
  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 int
type_to_option (SIM_DESC sd,
                watchpoint_type type,
                int interrupt_nr)
{
  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
  return ((type * (watch->nr_interrupts + 1))
          + interrupt_nr
          + OPTION_WATCH_OP);
}
 
 
/* 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_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);
          zfree (dead);
          status = SIM_RC_OK;
        }
      else
        entry = &(*entry)->next;
    }
  return status;
}
 
static 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;
}
 
static 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];
}
 
 
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
schedule_watchpoint (SIM_DESC sd,
                     sim_watch_point *point)
{
  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
  switch (point->type)
    {
    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;
}
 
 
static void
handle_watchpoint (SIM_DESC sd, void *data)
{
  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
do_watchpoint_create (SIM_DESC sd,
                      watchpoint_type type,
                      int opt,
                      char *arg)
{
  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++;
    }
 
  (*point)->arg0 = strtoul (arg, &arg, 0);
  if (arg[0] == ',')
    (*point)->arg0 = strtoul (arg, NULL, 0);
  else
    (*point)->arg1 = (*point)->arg0;
 
  /* schedule it */
  schedule_watchpoint (sd, (*point));
 
  return SIM_RC_OK;
}
 
 
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_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;
 
      }
 
}
 
 
static SIM_RC
sim_watchpoint_init (SIM_DESC sd)
{
  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
  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)
    {
      schedule_watchpoint (sd, point);
    }
  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 },
 
  { {"watch-info", no_argument, NULL, OPTION_WATCH_INFO },
      '\0', NULL, "List scheduled watchpoints",
      watchpoint_option_handler },
 
  { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
};
 
static char *default_interrupt_names[] = { "int", 0, };
 
 
 
SIM_RC
sim_watchpoint_install (SIM_DESC sd)
{
  sim_watchpoints *watch = STATE_WATCHPOINTS (sd);
  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
  /* the basic command set */
  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];
            asprintf (&name, "watch-%s-%s",
                      watchpoint_type_to_str (sd, type),
                      interrupt_nr_to_str (sd, interrupt_nr));
            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. */
    {
      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;
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [sim/] [common/] [sim-watch.c] - Blame information for rev 853

Line No.	Rev	Author	Line
1	227	jeremybenn	`/* Generic simulator watchpoint support.`
2			`Copyright (C) 1997, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.`
3			`Contributed by Cygnus Support.`
4
5			`This file is part of GDB, the GNU debugger.`
6
7			`This program is free software; you can redistribute it and/or modify`
8			`it under the terms of the GNU General Public License as published by`
9			`the Free Software Foundation; either version 3 of the License, or`
10			`(at your option) any later version.`
11
12			`This program is distributed in the hope that it will be useful,`
13			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`GNU General Public License for more details.`
16
17			`You should have received a copy of the GNU General Public License`
18			`along with this program. If not, see <http://www.gnu.org/licenses/>. */`
19
20			`#include "sim-main.h"`
21			`#include "sim-options.h"`
22
23			`#include "sim-assert.h"`
24
25			`#include <ctype.h>`
26
27			`#ifdef HAVE_STRING_H`
28			`#include <string.h>`
29			`#else`
30			`#ifdef HAVE_STRINGS_H`
31			`#include <strings.h>`
32			`#endif`
33			`#endif`
34
35			`#ifdef HAVE_STDLIB_H`
36			`#include <stdlib.h>`
37			`#endif`
38
39			`enum {`
40			`OPTION_WATCH_DELETE = OPTION_START,`
41
42			`OPTION_WATCH_INFO,`
43			`OPTION_WATCH_CLOCK,`
44			`OPTION_WATCH_CYCLES,`
45			`OPTION_WATCH_PC,`
46
47			`OPTION_WATCH_OP,`
48			`};`
49
50
51			`/* Break an option number into its op/int-nr */`
52			`static watchpoint_type`
53			`option_to_type (SIM_DESC sd,`
54			`int option)`
55			`{`
56			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
57			`watchpoint_type type = ((option - OPTION_WATCH_OP)`
58			`/ (watch->nr_interrupts + 1));`
59			`SIM_ASSERT (type >= 0 && type < nr_watchpoint_types);`
60			`return type;`
61			`}`
62
63			`static int`
64			`option_to_interrupt_nr (SIM_DESC sd,`
65			`int option)`
66			`{`
67			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
68			`int interrupt_nr = ((option - OPTION_WATCH_OP)`
69			`% (watch->nr_interrupts + 1));`
70			`return interrupt_nr;`
71			`}`
72
73			`static int`
74			`type_to_option (SIM_DESC sd,`
75			`watchpoint_type type,`
76			`int interrupt_nr)`
77			`{`
78			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
79			`return ((type * (watch->nr_interrupts + 1))`
80			`+ interrupt_nr`
81			`+ OPTION_WATCH_OP);`
82			`}`
83
84
85			`/* Delete one or more watchpoints. Fail if no watchpoints were found */`
86
87			`static SIM_RC`
88			`do_watchpoint_delete (SIM_DESC sd,`
89			`int ident,`
90			`watchpoint_type type)`
91			`{`
92			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
93			`sim_watch_point **entry = &watch->points;`
94			`SIM_RC status = SIM_RC_FAIL;`
95			`while ((*entry) != NULL)`
96			`{`
97			`if ((*entry)->ident == ident`
98			`\|\| (*entry)->type == type)`
99			`{`
100			`sim_watch_point dead = (entry);`
101			`(entry) = (entry)->next;`
102			`sim_events_deschedule (sd, dead->event);`
103			`zfree (dead);`
104			`status = SIM_RC_OK;`
105			`}`
106			`else`
107			`entry = &(*entry)->next;`
108			`}`
109			`return status;`
110			`}`
111
112			`static char *`
113			`watchpoint_type_to_str (SIM_DESC sd,`
114			`watchpoint_type type)`
115			`{`
116			`switch (type)`
117			`{`
118			`case pc_watchpoint:`
119			`return "pc";`
120			`case clock_watchpoint:`
121			`return "clock";`
122			`case cycles_watchpoint:`
123			`return "cycles";`
124			`case invalid_watchpoint:`
125			`case nr_watchpoint_types:`
126			`return "(invalid-type)";`
127			`}`
128			`return NULL;`
129			`}`
130
131			`static char *`
132			`interrupt_nr_to_str (SIM_DESC sd,`
133			`int interrupt_nr)`
134			`{`
135			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
136			`if (interrupt_nr < 0)`
137			`return "(invalid-interrupt)";`
138			`else if (interrupt_nr >= watch->nr_interrupts)`
139			`return "breakpoint";`
140			`else`
141			`return watch->interrupt_names[interrupt_nr];`
142			`}`
143
144
145			`static void`
146			`do_watchpoint_info (SIM_DESC sd)`
147			`{`
148			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
149			`sim_watch_point *point;`
150			`sim_io_printf (sd, "Watchpoints:\n");`
151			`for (point = watch->points; point != NULL; point = point->next)`
152			`{`
153			`sim_io_printf (sd, "%3d: watch %s %s ",`
154			`point->ident,`
155			`watchpoint_type_to_str (sd, point->type),`
156			`interrupt_nr_to_str (sd, point->interrupt_nr));`
157			`if (point->is_periodic)`
158			`sim_io_printf (sd, "+");`
159			`if (!point->is_within)`
160			`sim_io_printf (sd, "!");`
161			`sim_io_printf (sd, "0x%lx", point->arg0);`
162			`if (point->arg1 != point->arg0)`
163			`sim_io_printf (sd, ",0x%lx", point->arg1);`
164			`sim_io_printf (sd, "\n");`
165			`}`
166			`}`
167
168
169
170			`static sim_event_handler handle_watchpoint;`
171
172			`static SIM_RC`
173			`schedule_watchpoint (SIM_DESC sd,`
174			`sim_watch_point *point)`
175			`{`
176			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
177			`switch (point->type)`
178			`{`
179			`case pc_watchpoint:`
180			`point->event = sim_events_watch_sim (sd,`
181			`watch->pc,`
182			`watch->sizeof_pc,`
183			`0/* host-endian */,`
184			`point->is_within,`
185			`point->arg0, point->arg1,`
186			`/* PC in arg0..arg1 */`
187			`handle_watchpoint,`
188			`point);`
189			`return SIM_RC_OK;`
190			`case clock_watchpoint:`
191			`point->event = sim_events_watch_clock (sd,`
192			`point->arg0, /* ms time */`
193			`handle_watchpoint,`
194			`point);`
195			`return SIM_RC_OK;`
196			`case cycles_watchpoint:`
197			`point->event = sim_events_schedule (sd,`
198			`point->arg0, /* time */`
199			`handle_watchpoint,`
200			`point);`
201			`return SIM_RC_OK;`
202			`default:`
203			`sim_engine_abort (sd, NULL, NULL_CIA,`
204			`"handle_watchpoint - internal error - bad switch");`
205			`return SIM_RC_FAIL;`
206			`}`
207			`return SIM_RC_OK;`
208			`}`
209
210
211			`static void`
212			`handle_watchpoint (SIM_DESC sd, void *data)`
213			`{`
214			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
215			`sim_watch_point point = (sim_watch_point ) data;`
216			`int interrupt_nr = point->interrupt_nr;`
217
218			`if (point->is_periodic)`
219			`/* reschedule this event before processing it */`
220			`schedule_watchpoint (sd, point);`
221			`else`
222			`do_watchpoint_delete (sd, point->ident, invalid_watchpoint);`
223
224			`if (point->interrupt_nr == watch->nr_interrupts)`
225			`sim_engine_halt (sd, NULL, NULL, NULL_CIA, sim_stopped, SIM_SIGINT);`
226			`else`
227			`watch->interrupt_handler (sd, &watch->interrupt_names[interrupt_nr]);`
228			`}`
229
230
231			`static SIM_RC`
232			`do_watchpoint_create (SIM_DESC sd,`
233			`watchpoint_type type,`
234			`int opt,`
235			`char *arg)`
236			`{`
237			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
238			`sim_watch_point **point;`
239
240			`/* create the watchpoint */`
241			`point = &watch->points;`
242			`while ((*point) != NULL)`
243			`point = &(*point)->next;`
244			`(*point) = ZALLOC (sim_watch_point);`
245
246			`/* fill in the details */`
247			`(*point)->ident = ++(watch->last_point_nr);`
248			`(*point)->type = option_to_type (sd, opt);`
249			`(*point)->interrupt_nr = option_to_interrupt_nr (sd, opt);`
250			`/* prefixes to arg - +== periodic, !==not or outside */`
251			`(*point)->is_within = 1;`
252			`while (1)`
253			`{`
254			`if (arg[0] == '+')`
255			`(*point)->is_periodic = 1;`
256			`else if (arg[0] == '!')`
257			`(*point)->is_within = 0;`
258			`else`
259			`break;`
260			`arg++;`
261			`}`
262
263			`(*point)->arg0 = strtoul (arg, &arg, 0);`
264			`if (arg[0] == ',')`
265			`(*point)->arg0 = strtoul (arg, NULL, 0);`
266			`else`
267			`(point)->arg1 = (point)->arg0;`
268
269			`/* schedule it */`
270			`schedule_watchpoint (sd, (*point));`
271
272			`return SIM_RC_OK;`
273			`}`
274
275
276			`static SIM_RC`
277			`watchpoint_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,`
278			`char *arg, int is_command)`
279			`{`
280			`if (opt >= OPTION_WATCH_OP)`
281			`return do_watchpoint_create (sd, clock_watchpoint, opt, arg);`
282			`else`
283			`switch (opt)`
284			`{`
285
286			`case OPTION_WATCH_DELETE:`
287			`if (isdigit ((int) arg[0]))`
288			`{`
289			`int ident = strtol (arg, NULL, 0);`
290			`if (do_watchpoint_delete (sd, ident, invalid_watchpoint)`
291			`!= SIM_RC_OK)`
292			`{`
293			`sim_io_eprintf (sd, "Watchpoint %d not found\n", ident);`
294			`return SIM_RC_FAIL;`
295			`}`
296			`return SIM_RC_OK;`
297			`}`
298			`else if (strcasecmp (arg, "all") == 0)`
299			`{`
300			`watchpoint_type type;`
301			`for (type = invalid_watchpoint + 1;`
302			`type < nr_watchpoint_types;`
303			`type++)`
304			`{`
305			`do_watchpoint_delete (sd, 0, type);`
306			`}`
307			`return SIM_RC_OK;`
308			`}`
309			`else if (strcasecmp (arg, "pc") == 0)`
310			`{`
311			`if (do_watchpoint_delete (sd, 0, pc_watchpoint)`
312			`!= SIM_RC_OK)`
313			`{`
314			`sim_io_eprintf (sd, "No PC watchpoints found\n");`
315			`return SIM_RC_FAIL;`
316			`}`
317			`return SIM_RC_OK;`
318			`}`
319			`else if (strcasecmp (arg, "clock") == 0)`
320			`{`
321			`if (do_watchpoint_delete (sd, 0, clock_watchpoint) != SIM_RC_OK)`
322			`{`
323			`sim_io_eprintf (sd, "No CLOCK watchpoints found\n");`
324			`return SIM_RC_FAIL;`
325			`}`
326			`return SIM_RC_OK;`
327			`}`
328			`else if (strcasecmp (arg, "cycles") == 0)`
329			`{`
330			`if (do_watchpoint_delete (sd, 0, cycles_watchpoint) != SIM_RC_OK)`
331			`{`
332			`sim_io_eprintf (sd, "No CYCLES watchpoints found\n");`
333			`return SIM_RC_FAIL;`
334			`}`
335			`return SIM_RC_OK;`
336			`}`
337			sim_io_eprintf (sd, "Unknown watchpoint type `%s'\n", arg);
338			`return SIM_RC_FAIL;`
339
340			`case OPTION_WATCH_INFO:`
341			`{`
342			`do_watchpoint_info (sd);`
343			`return SIM_RC_OK;`
344			`}`
345
346			`default:`
347			`sim_io_eprintf (sd, "Unknown watch option %d\n", opt);`
348			`return SIM_RC_FAIL;`
349
350			`}`
351
352			`}`
353
354
355			`static SIM_RC`
356			`sim_watchpoint_init (SIM_DESC sd)`
357			`{`
358			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
359			`sim_watch_point *point;`
360			`/* NOTE: Do not need to de-schedule any previous watchpoints as`
361			`sim-events has already done this */`
362			`/* schedule any watchpoints enabled by command line options */`
363			`for (point = watch->points; point != NULL; point = point->next)`
364			`{`
365			`schedule_watchpoint (sd, point);`
366			`}`
367			`return SIM_RC_OK;`
368			`}`
369
370
371			`static const OPTION watchpoint_options[] =`
372			`{`
373			`{ {"watch-delete", required_argument, NULL, OPTION_WATCH_DELETE },`
374			`'\0', "IDENT\|all\|pc\|cycles\|clock", "Delete a watchpoint",`
375			`watchpoint_option_handler },`
376
377			`{ {"watch-info", no_argument, NULL, OPTION_WATCH_INFO },`
378			`'\0', NULL, "List scheduled watchpoints",`
379			`watchpoint_option_handler },`
380
381			`{ {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }`
382			`};`
383
384			`static char *default_interrupt_names[] = { "int", 0, };`
385
386
387
388			`SIM_RC`
389			`sim_watchpoint_install (SIM_DESC sd)`
390			`{`
391			`sim_watchpoints *watch = STATE_WATCHPOINTS (sd);`
392			`SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);`
393			`/* the basic command set */`
394			`sim_module_add_init_fn (sd, sim_watchpoint_init);`
395			`sim_add_option_table (sd, NULL, watchpoint_options);`
396			`/* fill in some details */`
397			`if (watch->interrupt_names == NULL)`
398			`watch->interrupt_names = default_interrupt_names;`
399			`watch->nr_interrupts = 0;`
400			`while (watch->interrupt_names[watch->nr_interrupts] != NULL)`
401			`watch->nr_interrupts++;`
402			`/* generate more advansed commands */`
403			`{`
404			`OPTION int_options = NZALLOC (OPTION, 1 + (watch->nr_interrupts + 1) nr_watchpoint_types);`
405			`int interrupt_nr;`
406			`for (interrupt_nr = 0; interrupt_nr <= watch->nr_interrupts; interrupt_nr++)`
407			`{`
408			`watchpoint_type type;`
409			`for (type = 0; type < nr_watchpoint_types; type++)`
410			`{`
411			`char *name;`
412			`int nr = interrupt_nr * nr_watchpoint_types + type;`
413			`OPTION *option = &int_options[nr];`
414			`asprintf (&name, "watch-%s-%s",`
415			`watchpoint_type_to_str (sd, type),`
416			`interrupt_nr_to_str (sd, interrupt_nr));`
417			`option->opt.name = name;`
418			`option->opt.has_arg = required_argument;`
419			`option->opt.val = type_to_option (sd, type, interrupt_nr);`
420			`option->doc = "";`
421			`option->doc_name = "";`
422			`option->handler = watchpoint_option_handler;`
423			`}`
424			`}`
425			`/* adjust first few entries so that they contain real`
426			`documentation, the first entry includes a list of actions. */`
427			`{`
428			`char *prefix =`
429			"Watch the simulator, take ACTION in COUNT cycles (`+' for every COUNT cycles), ACTION is";
430			`char *doc;`
431			`int len = strlen (prefix) + 1;`
432			`for (interrupt_nr = 0; interrupt_nr <= watch->nr_interrupts; interrupt_nr++)`
433			`len += strlen (interrupt_nr_to_str (sd, interrupt_nr)) + 1;`
434			`doc = NZALLOC (char, len);`
435			`strcpy (doc, prefix);`
436			`for (interrupt_nr = 0; interrupt_nr <= watch->nr_interrupts; interrupt_nr++)`
437			`{`
438			`strcat (doc, " ");`
439			`strcat (doc, interrupt_nr_to_str (sd, interrupt_nr));`
440			`}`
441			`int_options[0].doc_name = "watch-cycles-ACTION";`
442			`int_options[0].arg = "[+]COUNT";`
443			`int_options[0].doc = doc;`
444			`}`
445			`int_options[1].doc_name = "watch-pc-ACTION";`
446			`int_options[1].arg = "[!]ADDRESS";`
447			`int_options[1].doc =`
448			"Watch the PC, take ACTION when matches ADDRESS (in range ADDRESS,ADDRESS), `!' negates test";
449			`int_options[2].doc_name = "watch-clock-ACTION";`
450			`int_options[2].arg = "[+]MILLISECONDS";`
451			`int_options[2].doc =`
452			"Watch the clock, take ACTION after MILLISECONDS (`+' for every MILLISECONDS)";
453
454			`sim_add_option_table (sd, NULL, int_options);`
455			`}`
456			`return SIM_RC_OK;`
457			`}`