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

/* 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
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 "config.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_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);
	  free (dead);
	  status = SIM_RC_OK;
	}
      else
	entry = &(*entry)->next;
    }
  return status;
}

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;
}

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];
}


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