[deliverable/binutils-gdb.git] / gdb / memattr.c

/* memattr.c */
#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"

/* FIXME: While this conflicts with the enum defined in breakpoint.h,
   I used them to be consistant with how breakpoints, tracepoints, and
   displays are implemented.  It doesn't lose now because breakpoint.h
   is not included.  */
enum enable
{
  disabled,
  enabled
};

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 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, *p, *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;
	}
    }

  new = xmalloc (sizeof (struct mem_region));
  new->lo = lo;
  new->hi = hi;
  new->number = ++mem_number;
  new->status = enabled;
  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)
{
  free (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->status == enabled)
	{
	  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 ("Memory regions now in effect:\n");
  for (m = mem_region_chain; m; m = m->next)
    {
      printf_filtered ("%d: %c\t",
		       m->number,
		       m->status ? 'y' : 'n');
      printf_filtered ("%s - ",
		    local_hex_string_custom ((unsigned long) m->lo, "08l"));
      printf_filtered ("%s\t",
		    local_hex_string_custom ((unsigned long) m->hi, "08l"));

      /* 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->status = enabled;
	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->status = enabled;
    }
  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->status = disabled;
	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->status = disabled;
    }
  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.");

  add_cmd ("mem", class_vars, mem_enable_command,
	   "Enable memory region.\n\
Arguments are the code numbers of the memory regions to enable.\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\
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\
Do \"info mem\" to see current list of code numbers.", &deletelist);

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