[binutils.git] / gdb / memattr.c

/* Memory attributes support, for GDB.
   Copyright 2001 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "command.h"
#include "gdbcmd.h"
#include "memattr.h"
#include "target.h"
#include "value.h"
#include "language.h"
#include "gdb_string.h"

const struct mem_attrib default_mem_attrib =
{
  MEM_RW,			/* mode */
  MEM_WIDTH_UNSPECIFIED,
  false,			/* hwbreak */
  false,			/* cache */
  false				/* verify */
};

static struct mem_region *mem_region_chain = NULL;
static int mem_number = 0;

static struct mem_region *
create_mem_region (CORE_ADDR lo, CORE_ADDR hi,
		   const struct mem_attrib *attrib)
{
  struct mem_region *n, *new;

  if (lo > hi)
    {
      printf_unfiltered ("invalid memory region\n");
      return NULL;
    }

  n = mem_region_chain;
  while (n)
    {
      /* overlapping node */
      if ((lo >= n->lo && lo <= n->hi) ||
	  (hi >= n->lo && hi <= n->hi))
	{
	  printf_unfiltered ("overlapping memory region\n");
	  return NULL;
	}
      n = n->next;
    }

  new = xmalloc (sizeof (struct mem_region));
  new->lo = lo;
  new->hi = hi;
  new->number = ++mem_number;
  new->enabled_p = 1;
  new->attrib = *attrib;

  /* link in new node */
  new->next = mem_region_chain;
  mem_region_chain = new;

  return new;
}

static void
delete_mem_region (struct mem_region *m)
{
  xfree (m);
}

/*
 * Look up the memory region cooresponding to ADDR.
 */
struct mem_region *
lookup_mem_region (CORE_ADDR addr)
{
  static struct mem_region region;
  struct mem_region *m;
  CORE_ADDR lo;
  CORE_ADDR hi;

  /* First we initialize LO and HI so that they describe the entire
     memory space.  As we process the memory region chain, they are
     redefined to describe the minimal region containing ADDR.  LO
     and HI are used in the case where no memory region is defined
     that contains ADDR.  If a memory region is disabled, it is
     treated as if it does not exist.  */

  lo = (CORE_ADDR) 0;
  hi = (CORE_ADDR) ~ 0;

  for (m = mem_region_chain; m; m = m->next)
    {
      if (m->enabled_p == 1)
	{
	  if (addr >= m->lo && addr < m->hi)
	    return m;

	  if (addr >= m->hi && lo < m->hi)
	    lo = m->hi;

	  if (addr <= m->lo && hi > m->lo)
	    hi = m->lo;
	}
    }

  /* Because no region was found, we must cons up one based on what
     was learned above.  */
  region.lo = lo;
  region.hi = hi;
  region.attrib = default_mem_attrib;
  return &region;
}
\f

static void
mem_command (char *args, int from_tty)
{
  CORE_ADDR lo, hi;
  char *tok;
  struct mem_attrib attrib;

  if (!args)
    error_no_arg ("No mem");

  tok = strtok (args, " \t");
  if (!tok)
    error ("no lo address");
  lo = parse_and_eval_address (tok);

  tok = strtok (NULL, " \t");
  if (!tok)
    error ("no hi address");
  hi = parse_and_eval_address (tok);

  attrib = default_mem_attrib;
  while ((tok = strtok (NULL, " \t")) != NULL)
    {
      if (strcmp (tok, "rw") == 0)
	attrib.mode = MEM_RW;
      else if (strcmp (tok, "ro") == 0)
	attrib.mode = MEM_RO;
      else if (strcmp (tok, "wo") == 0)
	attrib.mode = MEM_WO;

      else if (strcmp (tok, "8") == 0)
	attrib.width = MEM_WIDTH_8;
      else if (strcmp (tok, "16") == 0)
	{
	  if ((lo % 2 != 0) || (hi % 2 != 0))
	    error ("region bounds not 16 bit aligned");
	  attrib.width = MEM_WIDTH_16;
	}
      else if (strcmp (tok, "32") == 0)
	{
	  if ((lo % 4 != 0) || (hi % 4 != 0))
	    error ("region bounds not 32 bit aligned");
	  attrib.width = MEM_WIDTH_32;
	}
      else if (strcmp (tok, "64") == 0)
	{
	  if ((lo % 8 != 0) || (hi % 8 != 0))
	    error ("region bounds not 64 bit aligned");
	  attrib.width = MEM_WIDTH_64;
	}

#if 0
      else if (strcmp (tok, "hwbreak") == 0)
	attrib.hwbreak = true;
      else if (strcmp (tok, "swbreak") == 0)
	attrib.hwbreak = false;
#endif

      else if (strcmp (tok, "cache") == 0)
	attrib.cache = true;
      else if (strcmp (tok, "nocache") == 0)
	attrib.cache = false;

#if 0
      else if (strcmp (tok, "verify") == 0)
	attrib.verify = true;
      else if (strcmp (tok, "noverify") == 0)
	attrib.verify = false;
#endif

      else
	error ("unknown attribute: %s", tok);
    }

  create_mem_region (lo, hi, &attrib);
}
\f

static void
mem_info_command (char *args, int from_tty)
{
  struct mem_region *m;
  struct mem_attrib *attrib;

  if (!mem_region_chain)
    {
      printf_unfiltered ("There are no memory regions defined.\n");
      return;
    }

  printf_filtered ("Num ");
  printf_filtered ("Enb ");
  printf_filtered ("Low Addr   ");
  if (TARGET_ADDR_BIT > 32)
    printf_filtered ("        ");
  printf_filtered ("High Addr  ");
  if (TARGET_ADDR_BIT > 32)
    printf_filtered ("        ");
  printf_filtered ("Attrs ");
  printf_filtered ("\n");

  for (m = mem_region_chain; m; m = m->next)
    {
      char *tmp;
      printf_filtered ("%-3d %-3c\t",
		       m->number,
		       m->enabled_p ? 'y' : 'n');
      if (TARGET_ADDR_BIT <= 32)
	tmp = longest_local_hex_string_custom ((unsigned long) m->lo, "08l");
      else
	tmp = longest_local_hex_string_custom ((unsigned long) m->lo, "016l");
      
      printf_filtered ("%s ", tmp);
      
      if (TARGET_ADDR_BIT <= 32)
	tmp = longest_local_hex_string_custom ((unsigned long) m->hi, "08l");
      else
	tmp = longest_local_hex_string_custom ((unsigned long) m->hi, "016l");
      
      printf_filtered ("%s ", tmp);

      /* Print a token for each attribute.

       * FIXME: Should we output a comma after each token?  It may
       * make it easier for users to read, but we'd lose the ability
       * to cut-and-paste the list of attributes when defining a new
       * region.  Perhaps that is not important.
       *
       * FIXME: If more attributes are added to GDB, the output may
       * become cluttered and difficult for users to read.  At that
       * time, we may want to consider printing tokens only if they
       * are different from the default attribute.  */

      attrib = &m->attrib;
      switch (attrib->mode)
	{
	case MEM_RW:
	  printf_filtered ("rw ");
	  break;
	case MEM_RO:
	  printf_filtered ("ro ");
	  break;
	case MEM_WO:
	  printf_filtered ("wo ");
	  break;
	}

      switch (attrib->width)
	{
	case MEM_WIDTH_8:
	  printf_filtered ("8 ");
	  break;
	case MEM_WIDTH_16:
	  printf_filtered ("16 ");
	  break;
	case MEM_WIDTH_32:
	  printf_filtered ("32 ");
	  break;
	case MEM_WIDTH_64:
	  printf_filtered ("64 ");
	  break;
	case MEM_WIDTH_UNSPECIFIED:
	  break;
	}

#if 0
      if (attrib->hwbreak)
	printf_filtered ("hwbreak");
      else
	printf_filtered ("swbreak");
#endif

      if (attrib->cache)
	printf_filtered ("cache ");
      else
	printf_filtered ("nocache ");

#if 0
      if (attrib->verify)
	printf_filtered ("verify ");
      else
	printf_filtered ("noverify ");
#endif

      printf_filtered ("\n");

      gdb_flush (gdb_stdout);
    }
}
\f

/* Enable the memory region number NUM. */

static void
mem_enable (int num)
{
  struct mem_region *m;

  for (m = mem_region_chain; m; m = m->next)
    if (m->number == num)
      {
	m->enabled_p = 1;
	return;
      }
  printf_unfiltered ("No memory region number %d.\n", num);
}

static void
mem_enable_command (char *args, int from_tty)
{
  char *p = args;
  char *p1;
  int num;
  struct mem_region *m;

  dcache_invalidate (target_dcache);

  if (p == 0)
    {
      for (m = mem_region_chain; m; m = m->next)
	m->enabled_p = 1;
    }
  else
    while (*p)
      {
	p1 = p;
	while (*p1 >= '0' && *p1 <= '9')
	  p1++;
	if (*p1 && *p1 != ' ' && *p1 != '\t')
	  error ("Arguments must be memory region numbers.");

	num = atoi (p);
	mem_enable (num);

	p = p1;
	while (*p == ' ' || *p == '\t')
	  p++;
      }
}
\f

/* Disable the memory region number NUM. */

static void
mem_disable (int num)
{
  struct mem_region *m;

  for (m = mem_region_chain; m; m = m->next)
    if (m->number == num)
      {
	m->enabled_p = 0;
	return;
      }
  printf_unfiltered ("No memory region number %d.\n", num);
}

static void
mem_disable_command (char *args, int from_tty)
{
  char *p = args;
  char *p1;
  int num;
  struct mem_region *m;

  dcache_invalidate (target_dcache);

  if (p == 0)
    {
      for (m = mem_region_chain; m; m = m->next)
	m->enabled_p = 0;
    }
  else
    while (*p)
      {
	p1 = p;
	while (*p1 >= '0' && *p1 <= '9')
	  p1++;
	if (*p1 && *p1 != ' ' && *p1 != '\t')
	  error ("Arguments must be memory region numbers.");

	num = atoi (p);
	mem_disable (num);

	p = p1;
	while (*p == ' ' || *p == '\t')
	  p++;
      }
}

/* Clear memory region list */

static void
mem_clear (void)
{
  struct mem_region *m;

  while ((m = mem_region_chain) != 0)
    {
      mem_region_chain = m->next;
      delete_mem_region (m);
    }
}

/* Delete the memory region number NUM. */

static void
mem_delete (int num)
{
  struct mem_region *m1, *m;

  if (!mem_region_chain)
    {
      printf_unfiltered ("No memory region number %d.\n", num);
      return;
    }

  if (mem_region_chain->number == num)
    {
      m1 = mem_region_chain;
      mem_region_chain = m1->next;
      delete_mem_region (m1);
    }
  else
    for (m = mem_region_chain; m->next; m = m->next)
      {
	if (m->next->number == num)
	  {
	    m1 = m->next;
	    m->next = m1->next;
	    delete_mem_region (m1);
	    break;
	  }
      }
}

static void
mem_delete_command (char *args, int from_tty)
{
  char *p = args;
  char *p1;
  int num;

  dcache_invalidate (target_dcache);

  if (p == 0)
    {
      if (query ("Delete all memory regions? "))
	mem_clear ();
      dont_repeat ();
      return;
    }

  while (*p)
    {
      p1 = p;
      while (*p1 >= '0' && *p1 <= '9')
	p1++;
      if (*p1 && *p1 != ' ' && *p1 != '\t')
	error ("Arguments must be memory region numbers.");

      num = atoi (p);
      mem_delete (num);

      p = p1;
      while (*p == ' ' || *p == '\t')
	p++;
    }

  dont_repeat ();
}
\f
void
_initialize_mem ()
{
  add_com ("mem", class_vars, mem_command,
	   "Define attributes for memory region.\n\
Usage: mem <lo addr> <hi addr> [<mode> <width> <cache>]");

  add_cmd ("mem", class_vars, mem_enable_command,
	   "Enable memory region.\n\
Arguments are the code numbers of the memory regions to enable.\n\
Usage: enable mem <code number>\n\
Do \"info mem\" to see current list of code numbers.", &enablelist);

  add_cmd ("mem", class_vars, mem_disable_command,
	   "Disable memory region.\n\
Arguments are the code numbers of the memory regions to disable.\n\
Usage: disable mem <code number>\n\
Do \"info mem\" to see current list of code numbers.", &disablelist);

  add_cmd ("mem", class_vars, mem_delete_command,
	   "Delete memory region.\n\
Arguments are the code numbers of the memory regions to delete.\n\
Usage: delete mem <code number>\n\
Do \"info mem\" to see current list of code numbers.", &deletelist);

  add_info ("mem", mem_info_command,
	    "Memory region attributes");
}
Commit	Line	Data
80629b1b EZ	1	/* Memory attributes support, for GDB.
	2	Copyright 2001 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
	20
29e57380 C	21	#include "defs.h"
	22	#include "command.h"
	23	#include "gdbcmd.h"
	24	#include "memattr.h"
	25	#include "target.h"
	26	#include "value.h"
	27	#include "language.h"
	28	#include "gdb_string.h"
	29
29e57380 C	30	const struct mem_attrib default_mem_attrib =
	31	{
	32	MEM_RW, /* mode */
	33	MEM_WIDTH_UNSPECIFIED,
	34	false, /* hwbreak */
	35	false, /* cache */
	36	false /* verify */
	37	};
	38
	39	static struct mem_region *mem_region_chain = NULL;
f4d650ec	40	static int mem_number = 0;
29e57380 C	41
	42	static struct mem_region *
	43	create_mem_region (CORE_ADDR lo, CORE_ADDR hi,
	44	const struct mem_attrib *attrib)
	45	{
3172dc30	46	struct mem_region n, new;
29e57380 C	47
	48	if (lo > hi)
	49	{
	50	printf_unfiltered ("invalid memory region\n");
	51	return NULL;
	52	}
	53
	54	n = mem_region_chain;
	55	while (n)
	56	{
	57	/* overlapping node */
	58	if ((lo >= n->lo && lo <= n->hi) \|\|
	59	(hi >= n->lo && hi <= n->hi))
	60	{
	61	printf_unfiltered ("overlapping memory region\n");
	62	return NULL;
	63	}
2ed3d0b5	64	n = n->next;
29e57380 C	65	}
	66
	67	new = xmalloc (sizeof (struct mem_region));
	68	new->lo = lo;
	69	new->hi = hi;
	70	new->number = ++mem_number;
b5de0fa7	71	new->enabled_p = 1;
29e57380 C	72	new->attrib = *attrib;
	73
	74	/* link in new node */
	75	new->next = mem_region_chain;
	76	mem_region_chain = new;
	77
	78	return new;
	79	}
	80
	81	static void
	82	delete_mem_region (struct mem_region *m)
	83	{
f4d650ec	84	xfree (m);
29e57380 C	85	}
	86
	87	/*
	88	* Look up the memory region cooresponding to ADDR.
	89	*/
	90	struct mem_region *
	91	lookup_mem_region (CORE_ADDR addr)
	92	{
	93	static struct mem_region region;
	94	struct mem_region *m;
	95	CORE_ADDR lo;
	96	CORE_ADDR hi;
	97
	98	/* First we initialize LO and HI so that they describe the entire
	99	memory space. As we process the memory region chain, they are
	100	redefined to describe the minimal region containing ADDR. LO
	101	and HI are used in the case where no memory region is defined
	102	that contains ADDR. If a memory region is disabled, it is
	103	treated as if it does not exist. */
	104
	105	lo = (CORE_ADDR) 0;
	106	hi = (CORE_ADDR) ~ 0;
	107
	108	for (m = mem_region_chain; m; m = m->next)
	109	{
b5de0fa7	110	if (m->enabled_p == 1)
29e57380 C	111	{
	112	if (addr >= m->lo && addr < m->hi)
	113	return m;
	114
	115	if (addr >= m->hi && lo < m->hi)
	116	lo = m->hi;
	117
	118	if (addr <= m->lo && hi > m->lo)
	119	hi = m->lo;
	120	}
	121	}
	122
	123	/* Because no region was found, we must cons up one based on what
	124	was learned above. */
	125	region.lo = lo;
	126	region.hi = hi;
	127	region.attrib = default_mem_attrib;
	128	return &region;
	129	}
	130	\f
	131
	132	static void
	133	mem_command (char *args, int from_tty)
	134	{
	135	CORE_ADDR lo, hi;
	136	char *tok;
	137	struct mem_attrib attrib;
	138
	139	if (!args)
	140	error_no_arg ("No mem");
	141
	142	tok = strtok (args, " \t");
	143	if (!tok)
	144	error ("no lo address");
	145	lo = parse_and_eval_address (tok);
	146
	147	tok = strtok (NULL, " \t");
	148	if (!tok)
	149	error ("no hi address");
	150	hi = parse_and_eval_address (tok);
	151
	152	attrib = default_mem_attrib;
	153	while ((tok = strtok (NULL, " \t")) != NULL)
	154	{
	155	if (strcmp (tok, "rw") == 0)
	156	attrib.mode = MEM_RW;
	157	else if (strcmp (tok, "ro") == 0)
	158	attrib.mode = MEM_RO;
	159	else if (strcmp (tok, "wo") == 0)
	160	attrib.mode = MEM_WO;
	161
	162	else if (strcmp (tok, "8") == 0)
	163	attrib.width = MEM_WIDTH_8;
	164	else if (strcmp (tok, "16") == 0)
	165	{
	166	if ((lo % 2 != 0) \|\| (hi % 2 != 0))
	167	error ("region bounds not 16 bit aligned");
	168	attrib.width = MEM_WIDTH_16;
	169	}
	170	else if (strcmp (tok, "32") == 0)
	171	{
	172	if ((lo % 4 != 0) \|\| (hi % 4 != 0))
	173	error ("region bounds not 32 bit aligned");
	174	attrib.width = MEM_WIDTH_32;
175	}
176	else if (strcmp (tok, "64") == 0)
177	{
178	if ((lo % 8 != 0) \|\| (hi % 8 != 0))
179	error ("region bounds not 64 bit aligned");
180	attrib.width = MEM_WIDTH_64;
181	}
182
183	#if 0
184	else if (strcmp (tok, "hwbreak") == 0)
185	attrib.hwbreak = true;
186	else if (strcmp (tok, "swbreak") == 0)
187	attrib.hwbreak = false;
188	#endif
189
190	else if (strcmp (tok, "cache") == 0)
191	attrib.cache = true;
192	else if (strcmp (tok, "nocache") == 0)
193	attrib.cache = false;
194
195	#if 0
196	else if (strcmp (tok, "verify") == 0)
197	attrib.verify = true;
198	else if (strcmp (tok, "noverify") == 0)
199	attrib.verify = false;
200	#endif
201
202	else
203	error ("unknown attribute: %s", tok);
204	}
205
206	create_mem_region (lo, hi, &attrib);
207	}
208	\f
209
210	static void
211	mem_info_command (char *args, int from_tty)
212	{
213	struct mem_region *m;
214	struct mem_attrib *attrib;
215
216	if (!mem_region_chain)
217	{
218	printf_unfiltered ("There are no memory regions defined.\n");
219	return;
220	}
221
ab35b611 EZ	222	printf_filtered ("Num ");
	223	printf_filtered ("Enb ");
	224	printf_filtered ("Low Addr ");
	225	if (TARGET_ADDR_BIT > 32)
	226	printf_filtered (" ");
	227	printf_filtered ("High Addr ");
	228	if (TARGET_ADDR_BIT > 32)
	229	printf_filtered (" ");
	230	printf_filtered ("Attrs ");
	231	printf_filtered ("\n");
	232
29e57380 C	233	for (m = mem_region_chain; m; m = m->next)
29e57380 C	234	{
ab35b611 EZ	235	char *tmp;
ab35b611 EZ	236	printf_filtered ("%-3d %-3c\t",
29e57380	237	m->number,
b5de0fa7	238	m->enabled_p ? 'y' : 'n');
ab35b611 EZ	239	if (TARGET_ADDR_BIT <= 32)
	240	tmp = longest_local_hex_string_custom ((unsigned long) m->lo, "08l");
	241	else
	242	tmp = longest_local_hex_string_custom ((unsigned long) m->lo, "016l");
	243
	244	printf_filtered ("%s ", tmp);
	245
	246	if (TARGET_ADDR_BIT <= 32)
	247	tmp = longest_local_hex_string_custom ((unsigned long) m->hi, "08l");
	248	else
	249	tmp = longest_local_hex_string_custom ((unsigned long) m->hi, "016l");
	250
	251	printf_filtered ("%s ", tmp);
29e57380 C	252
	253	/* Print a token for each attribute.
	254
	255	* FIXME: Should we output a comma after each token? It may
	256	* make it easier for users to read, but we'd lose the ability
	257	* to cut-and-paste the list of attributes when defining a new
	258	* region. Perhaps that is not important.
	259	*
	260	* FIXME: If more attributes are added to GDB, the output may
	261	* become cluttered and difficult for users to read. At that
	262	* time, we may want to consider printing tokens only if they
	263	* are different from the default attribute. */
	264
	265	attrib = &m->attrib;
	266	switch (attrib->mode)
	267	{
	268	case MEM_RW:
	269	printf_filtered ("rw ");
	270	break;
	271	case MEM_RO:
	272	printf_filtered ("ro ");
	273	break;
	274	case MEM_WO:
	275	printf_filtered ("wo ");
	276	break;
	277	}
	278
	279	switch (attrib->width)
	280	{
	281	case MEM_WIDTH_8:
	282	printf_filtered ("8 ");
	283	break;
	284	case MEM_WIDTH_16:
	285	printf_filtered ("16 ");
	286	break;
	287	case MEM_WIDTH_32:
	288	printf_filtered ("32 ");
	289	break;
	290	case MEM_WIDTH_64:
	291	printf_filtered ("64 ");
	292	break;
	293	case MEM_WIDTH_UNSPECIFIED:
	294	break;
	295	}
	296
	297	#if 0
	298	if (attrib->hwbreak)
	299	printf_filtered ("hwbreak");
	300	else
	301	printf_filtered ("swbreak");
	302	#endif
	303
	304	if (attrib->cache)
	305	printf_filtered ("cache ");
	306	else
	307	printf_filtered ("nocache ");
	308
	309	#if 0
	310	if (attrib->verify)
	311	printf_filtered ("verify ");
	312	else
	313	printf_filtered ("noverify ");
	314	#endif
	315
316	printf_filtered ("\n");
317
318	gdb_flush (gdb_stdout);
319	}
320	}
321	\f
322
323	/* Enable the memory region number NUM. */
324
325	static void
326	mem_enable (int num)
327	{
328	struct mem_region *m;
329
330	for (m = mem_region_chain; m; m = m->next)
331	if (m->number == num)
332	{
b5de0fa7	333	m->enabled_p = 1;
29e57380 C	334	return;
	335	}
	336	printf_unfiltered ("No memory region number %d.\n", num);
	337	}
	338
	339	static void
	340	mem_enable_command (char *args, int from_tty)
	341	{
	342	char *p = args;
	343	char *p1;
	344	int num;
	345	struct mem_region *m;
	346
	347	dcache_invalidate (target_dcache);
	348
	349	if (p == 0)
	350	{
	351	for (m = mem_region_chain; m; m = m->next)
b5de0fa7	352	m->enabled_p = 1;
29e57380 C	353	}
	354	else
	355	while (*p)
	356	{
	357	p1 = p;
	358	while (p1 >= '0' && p1 <= '9')
	359	p1++;
	360	if (p1 && p1 != ' ' && *p1 != '\t')
	361	error ("Arguments must be memory region numbers.");
	362
	363	num = atoi (p);
	364	mem_enable (num);
	365
	366	p = p1;
	367	while (p == ' ' \|\| p == '\t')
	368	p++;
	369	}
	370	}
	371	\f
	372
	373	/* Disable the memory region number NUM. */
	374
	375	static void
	376	mem_disable (int num)
	377	{
	378	struct mem_region *m;
	379
	380	for (m = mem_region_chain; m; m = m->next)
	381	if (m->number == num)
	382	{
b5de0fa7	383	m->enabled_p = 0;
29e57380 C	384	return;
	385	}
	386	printf_unfiltered ("No memory region number %d.\n", num);
	387	}
	388
	389	static void
	390	mem_disable_command (char *args, int from_tty)
	391	{
	392	char *p = args;
	393	char *p1;
	394	int num;
	395	struct mem_region *m;
	396
	397	dcache_invalidate (target_dcache);
	398
	399	if (p == 0)
	400	{
	401	for (m = mem_region_chain; m; m = m->next)
b5de0fa7	402	m->enabled_p = 0;
29e57380 C	403	}
	404	else
	405	while (*p)
	406	{
	407	p1 = p;
	408	while (p1 >= '0' && p1 <= '9')
	409	p1++;
	410	if (p1 && p1 != ' ' && *p1 != '\t')
	411	error ("Arguments must be memory region numbers.");
	412
	413	num = atoi (p);
	414	mem_disable (num);
	415
	416	p = p1;
	417	while (p == ' ' \|\| p == '\t')
	418	p++;
	419	}
	420	}
	421
	422	/* Clear memory region list */
	423
	424	static void
	425	mem_clear (void)
	426	{
	427	struct mem_region *m;
	428
	429	while ((m = mem_region_chain) != 0)
	430	{
	431	mem_region_chain = m->next;
	432	delete_mem_region (m);
	433	}
	434	}
	435
	436	/* Delete the memory region number NUM. */
	437
	438	static void
	439	mem_delete (int num)
	440	{
	441	struct mem_region m1, m;
	442
	443	if (!mem_region_chain)
	444	{
	445	printf_unfiltered ("No memory region number %d.\n", num);
	446	return;
	447	}
	448
	449	if (mem_region_chain->number == num)
	450	{
	451	m1 = mem_region_chain;
	452	mem_region_chain = m1->next;
	453	delete_mem_region (m1);
	454	}
	455	else
	456	for (m = mem_region_chain; m->next; m = m->next)
	457	{
	458	if (m->next->number == num)
	459	{
	460	m1 = m->next;
	461	m->next = m1->next;
	462	delete_mem_region (m1);
	463	break;
	464	}
	465	}
	466	}
467
468	static void
469	mem_delete_command (char *args, int from_tty)
470	{
471	char *p = args;
472	char *p1;
473	int num;
474
475	dcache_invalidate (target_dcache);
476
477	if (p == 0)
478	{
479	if (query ("Delete all memory regions? "))
480	mem_clear ();
481	dont_repeat ();
482	return;
483	}
484
485	while (*p)
486	{
487	p1 = p;
488	while (p1 >= '0' && p1 <= '9')
489	p1++;
490	if (p1 && p1 != ' ' && *p1 != '\t')
491	error ("Arguments must be memory region numbers.");
492
493	num = atoi (p);
494	mem_delete (num);
495
496	p = p1;
497	while (p == ' ' \|\| p == '\t')
498	p++;
499	}
500
501	dont_repeat ();
502	}
503	\f
504	void
505	_initialize_mem ()
506	{
507	add_com ("mem", class_vars, mem_command,
ab35b611 EZ	508	"Define attributes for memory region.\n\
ab35b611 EZ	509	Usage: mem <lo addr> <hi addr> [<mode> <width> <cache>]");
29e57380 C	510
	511	add_cmd ("mem", class_vars, mem_enable_command,
	512	"Enable memory region.\n\
	513	Arguments are the code numbers of the memory regions to enable.\n\
ab35b611	514	Usage: enable mem <code number>\n\
29e57380 C	515	Do \"info mem\" to see current list of code numbers.", &enablelist);
	516
	517	add_cmd ("mem", class_vars, mem_disable_command,
	518	"Disable memory region.\n\
	519	Arguments are the code numbers of the memory regions to disable.\n\
ab35b611	520	Usage: disable mem <code number>\n\
29e57380 C	521	Do \"info mem\" to see current list of code numbers.", &disablelist);
	522
	523	add_cmd ("mem", class_vars, mem_delete_command,
	524	"Delete memory region.\n\
	525	Arguments are the code numbers of the memory regions to delete.\n\
ab35b611	526	Usage: delete mem <code number>\n\
29e57380 C	527	Do \"info mem\" to see current list of code numbers.", &deletelist);
	528
	529	add_info ("mem", mem_info_command,
	530	"Memory region attributes");
	531	}