/* Memory attributes support, for GDB.
|
/* Memory attributes support, for GDB.
|
Copyright 2001 Free Software Foundation, Inc.
|
Copyright 2001 Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 2 of the License, or
|
the Free Software Foundation; either version 2 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Boston, MA 02111-1307, USA. */
|
Boston, MA 02111-1307, USA. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "command.h"
|
#include "command.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "memattr.h"
|
#include "memattr.h"
|
#include "target.h"
|
#include "target.h"
|
#include "value.h"
|
#include "value.h"
|
#include "language.h"
|
#include "language.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
|
|
/* FIXME: While this conflicts with the enum defined in breakpoint.h,
|
/* FIXME: While this conflicts with the enum defined in breakpoint.h,
|
I used them to be consistant with how breakpoints, tracepoints, and
|
I used them to be consistant with how breakpoints, tracepoints, and
|
displays are implemented. It doesn't lose now because breakpoint.h
|
displays are implemented. It doesn't lose now because breakpoint.h
|
is not included. */
|
is not included. */
|
enum enable
|
enum enable
|
{
|
{
|
disabled,
|
disabled,
|
enabled
|
enabled
|
};
|
};
|
|
|
const struct mem_attrib default_mem_attrib =
|
const struct mem_attrib default_mem_attrib =
|
{
|
{
|
MEM_RW, /* mode */
|
MEM_RW, /* mode */
|
MEM_WIDTH_UNSPECIFIED,
|
MEM_WIDTH_UNSPECIFIED,
|
false, /* hwbreak */
|
false, /* hwbreak */
|
false, /* cache */
|
false, /* cache */
|
false /* verify */
|
false /* verify */
|
};
|
};
|
|
|
static struct mem_region *mem_region_chain = NULL;
|
static struct mem_region *mem_region_chain = NULL;
|
static int mem_number = 0;
|
static int mem_number = 0;
|
|
|
static struct mem_region *
|
static struct mem_region *
|
create_mem_region (CORE_ADDR lo, CORE_ADDR hi,
|
create_mem_region (CORE_ADDR lo, CORE_ADDR hi,
|
const struct mem_attrib *attrib)
|
const struct mem_attrib *attrib)
|
{
|
{
|
struct mem_region *n, *new;
|
struct mem_region *n, *new;
|
|
|
if (lo > hi)
|
if (lo > hi)
|
{
|
{
|
printf_unfiltered ("invalid memory region\n");
|
printf_unfiltered ("invalid memory region\n");
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
n = mem_region_chain;
|
n = mem_region_chain;
|
while (n)
|
while (n)
|
{
|
{
|
/* overlapping node */
|
/* overlapping node */
|
if ((lo >= n->lo && lo <= n->hi) ||
|
if ((lo >= n->lo && lo <= n->hi) ||
|
(hi >= n->lo && hi <= n->hi))
|
(hi >= n->lo && hi <= n->hi))
|
{
|
{
|
printf_unfiltered ("overlapping memory region\n");
|
printf_unfiltered ("overlapping memory region\n");
|
return NULL;
|
return NULL;
|
}
|
}
|
n = n->next;
|
n = n->next;
|
}
|
}
|
|
|
new = xmalloc (sizeof (struct mem_region));
|
new = xmalloc (sizeof (struct mem_region));
|
new->lo = lo;
|
new->lo = lo;
|
new->hi = hi;
|
new->hi = hi;
|
new->number = ++mem_number;
|
new->number = ++mem_number;
|
new->status = enabled;
|
new->status = enabled;
|
new->attrib = *attrib;
|
new->attrib = *attrib;
|
|
|
/* link in new node */
|
/* link in new node */
|
new->next = mem_region_chain;
|
new->next = mem_region_chain;
|
mem_region_chain = new;
|
mem_region_chain = new;
|
|
|
return new;
|
return new;
|
}
|
}
|
|
|
static void
|
static void
|
delete_mem_region (struct mem_region *m)
|
delete_mem_region (struct mem_region *m)
|
{
|
{
|
xfree (m);
|
xfree (m);
|
}
|
}
|
|
|
/*
|
/*
|
* Look up the memory region cooresponding to ADDR.
|
* Look up the memory region cooresponding to ADDR.
|
*/
|
*/
|
struct mem_region *
|
struct mem_region *
|
lookup_mem_region (CORE_ADDR addr)
|
lookup_mem_region (CORE_ADDR addr)
|
{
|
{
|
static struct mem_region region;
|
static struct mem_region region;
|
struct mem_region *m;
|
struct mem_region *m;
|
CORE_ADDR lo;
|
CORE_ADDR lo;
|
CORE_ADDR hi;
|
CORE_ADDR hi;
|
|
|
/* First we initialize LO and HI so that they describe the entire
|
/* First we initialize LO and HI so that they describe the entire
|
memory space. As we process the memory region chain, they are
|
memory space. As we process the memory region chain, they are
|
redefined to describe the minimal region containing ADDR. LO
|
redefined to describe the minimal region containing ADDR. LO
|
and HI are used in the case where no memory region is defined
|
and HI are used in the case where no memory region is defined
|
that contains ADDR. If a memory region is disabled, it is
|
that contains ADDR. If a memory region is disabled, it is
|
treated as if it does not exist. */
|
treated as if it does not exist. */
|
|
|
lo = (CORE_ADDR) 0;
|
lo = (CORE_ADDR) 0;
|
hi = (CORE_ADDR) ~ 0;
|
hi = (CORE_ADDR) ~ 0;
|
|
|
for (m = mem_region_chain; m; m = m->next)
|
for (m = mem_region_chain; m; m = m->next)
|
{
|
{
|
if (m->status == enabled)
|
if (m->status == enabled)
|
{
|
{
|
if (addr >= m->lo && addr < m->hi)
|
if (addr >= m->lo && addr < m->hi)
|
return m;
|
return m;
|
|
|
if (addr >= m->hi && lo < m->hi)
|
if (addr >= m->hi && lo < m->hi)
|
lo = m->hi;
|
lo = m->hi;
|
|
|
if (addr <= m->lo && hi > m->lo)
|
if (addr <= m->lo && hi > m->lo)
|
hi = m->lo;
|
hi = m->lo;
|
}
|
}
|
}
|
}
|
|
|
/* Because no region was found, we must cons up one based on what
|
/* Because no region was found, we must cons up one based on what
|
was learned above. */
|
was learned above. */
|
region.lo = lo;
|
region.lo = lo;
|
region.hi = hi;
|
region.hi = hi;
|
region.attrib = default_mem_attrib;
|
region.attrib = default_mem_attrib;
|
return ®ion;
|
return ®ion;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
mem_command (char *args, int from_tty)
|
mem_command (char *args, int from_tty)
|
{
|
{
|
CORE_ADDR lo, hi;
|
CORE_ADDR lo, hi;
|
char *tok;
|
char *tok;
|
struct mem_attrib attrib;
|
struct mem_attrib attrib;
|
|
|
if (!args)
|
if (!args)
|
error_no_arg ("No mem");
|
error_no_arg ("No mem");
|
|
|
tok = strtok (args, " \t");
|
tok = strtok (args, " \t");
|
if (!tok)
|
if (!tok)
|
error ("no lo address");
|
error ("no lo address");
|
lo = parse_and_eval_address (tok);
|
lo = parse_and_eval_address (tok);
|
|
|
tok = strtok (NULL, " \t");
|
tok = strtok (NULL, " \t");
|
if (!tok)
|
if (!tok)
|
error ("no hi address");
|
error ("no hi address");
|
hi = parse_and_eval_address (tok);
|
hi = parse_and_eval_address (tok);
|
|
|
attrib = default_mem_attrib;
|
attrib = default_mem_attrib;
|
while ((tok = strtok (NULL, " \t")) != NULL)
|
while ((tok = strtok (NULL, " \t")) != NULL)
|
{
|
{
|
if (strcmp (tok, "rw") == 0)
|
if (strcmp (tok, "rw") == 0)
|
attrib.mode = MEM_RW;
|
attrib.mode = MEM_RW;
|
else if (strcmp (tok, "ro") == 0)
|
else if (strcmp (tok, "ro") == 0)
|
attrib.mode = MEM_RO;
|
attrib.mode = MEM_RO;
|
else if (strcmp (tok, "wo") == 0)
|
else if (strcmp (tok, "wo") == 0)
|
attrib.mode = MEM_WO;
|
attrib.mode = MEM_WO;
|
|
|
else if (strcmp (tok, "8") == 0)
|
else if (strcmp (tok, "8") == 0)
|
attrib.width = MEM_WIDTH_8;
|
attrib.width = MEM_WIDTH_8;
|
else if (strcmp (tok, "16") == 0)
|
else if (strcmp (tok, "16") == 0)
|
{
|
{
|
if ((lo % 2 != 0) || (hi % 2 != 0))
|
if ((lo % 2 != 0) || (hi % 2 != 0))
|
error ("region bounds not 16 bit aligned");
|
error ("region bounds not 16 bit aligned");
|
attrib.width = MEM_WIDTH_16;
|
attrib.width = MEM_WIDTH_16;
|
}
|
}
|
else if (strcmp (tok, "32") == 0)
|
else if (strcmp (tok, "32") == 0)
|
{
|
{
|
if ((lo % 4 != 0) || (hi % 4 != 0))
|
if ((lo % 4 != 0) || (hi % 4 != 0))
|
error ("region bounds not 32 bit aligned");
|
error ("region bounds not 32 bit aligned");
|
attrib.width = MEM_WIDTH_32;
|
attrib.width = MEM_WIDTH_32;
|
}
|
}
|
else if (strcmp (tok, "64") == 0)
|
else if (strcmp (tok, "64") == 0)
|
{
|
{
|
if ((lo % 8 != 0) || (hi % 8 != 0))
|
if ((lo % 8 != 0) || (hi % 8 != 0))
|
error ("region bounds not 64 bit aligned");
|
error ("region bounds not 64 bit aligned");
|
attrib.width = MEM_WIDTH_64;
|
attrib.width = MEM_WIDTH_64;
|
}
|
}
|
|
|
#if 0
|
#if 0
|
else if (strcmp (tok, "hwbreak") == 0)
|
else if (strcmp (tok, "hwbreak") == 0)
|
attrib.hwbreak = true;
|
attrib.hwbreak = true;
|
else if (strcmp (tok, "swbreak") == 0)
|
else if (strcmp (tok, "swbreak") == 0)
|
attrib.hwbreak = false;
|
attrib.hwbreak = false;
|
#endif
|
#endif
|
|
|
else if (strcmp (tok, "cache") == 0)
|
else if (strcmp (tok, "cache") == 0)
|
attrib.cache = true;
|
attrib.cache = true;
|
else if (strcmp (tok, "nocache") == 0)
|
else if (strcmp (tok, "nocache") == 0)
|
attrib.cache = false;
|
attrib.cache = false;
|
|
|
#if 0
|
#if 0
|
else if (strcmp (tok, "verify") == 0)
|
else if (strcmp (tok, "verify") == 0)
|
attrib.verify = true;
|
attrib.verify = true;
|
else if (strcmp (tok, "noverify") == 0)
|
else if (strcmp (tok, "noverify") == 0)
|
attrib.verify = false;
|
attrib.verify = false;
|
#endif
|
#endif
|
|
|
else
|
else
|
error ("unknown attribute: %s", tok);
|
error ("unknown attribute: %s", tok);
|
}
|
}
|
|
|
create_mem_region (lo, hi, &attrib);
|
create_mem_region (lo, hi, &attrib);
|
}
|
}
|
|
|
|
|
static void
|
static void
|
mem_info_command (char *args, int from_tty)
|
mem_info_command (char *args, int from_tty)
|
{
|
{
|
struct mem_region *m;
|
struct mem_region *m;
|
struct mem_attrib *attrib;
|
struct mem_attrib *attrib;
|
|
|
if (!mem_region_chain)
|
if (!mem_region_chain)
|
{
|
{
|
printf_unfiltered ("There are no memory regions defined.\n");
|
printf_unfiltered ("There are no memory regions defined.\n");
|
return;
|
return;
|
}
|
}
|
|
|
printf_filtered ("Memory regions now in effect:\n");
|
printf_filtered ("Memory regions now in effect:\n");
|
for (m = mem_region_chain; m; m = m->next)
|
for (m = mem_region_chain; m; m = m->next)
|
{
|
{
|
printf_filtered ("%d: %c\t",
|
printf_filtered ("%d: %c\t",
|
m->number,
|
m->number,
|
m->status ? 'y' : 'n');
|
m->status ? 'y' : 'n');
|
printf_filtered ("%s - ",
|
printf_filtered ("%s - ",
|
local_hex_string_custom ((unsigned long) m->lo, "08l"));
|
local_hex_string_custom ((unsigned long) m->lo, "08l"));
|
printf_filtered ("%s\t",
|
printf_filtered ("%s\t",
|
local_hex_string_custom ((unsigned long) m->hi, "08l"));
|
local_hex_string_custom ((unsigned long) m->hi, "08l"));
|
|
|
/* Print a token for each attribute.
|
/* Print a token for each attribute.
|
|
|
* FIXME: Should we output a comma after each token? It may
|
* FIXME: Should we output a comma after each token? It may
|
* make it easier for users to read, but we'd lose the ability
|
* 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
|
* to cut-and-paste the list of attributes when defining a new
|
* region. Perhaps that is not important.
|
* region. Perhaps that is not important.
|
*
|
*
|
* FIXME: If more attributes are added to GDB, the output may
|
* FIXME: If more attributes are added to GDB, the output may
|
* become cluttered and difficult for users to read. At that
|
* become cluttered and difficult for users to read. At that
|
* time, we may want to consider printing tokens only if they
|
* time, we may want to consider printing tokens only if they
|
* are different from the default attribute. */
|
* are different from the default attribute. */
|
|
|
attrib = &m->attrib;
|
attrib = &m->attrib;
|
switch (attrib->mode)
|
switch (attrib->mode)
|
{
|
{
|
case MEM_RW:
|
case MEM_RW:
|
printf_filtered ("rw ");
|
printf_filtered ("rw ");
|
break;
|
break;
|
case MEM_RO:
|
case MEM_RO:
|
printf_filtered ("ro ");
|
printf_filtered ("ro ");
|
break;
|
break;
|
case MEM_WO:
|
case MEM_WO:
|
printf_filtered ("wo ");
|
printf_filtered ("wo ");
|
break;
|
break;
|
}
|
}
|
|
|
switch (attrib->width)
|
switch (attrib->width)
|
{
|
{
|
case MEM_WIDTH_8:
|
case MEM_WIDTH_8:
|
printf_filtered ("8 ");
|
printf_filtered ("8 ");
|
break;
|
break;
|
case MEM_WIDTH_16:
|
case MEM_WIDTH_16:
|
printf_filtered ("16 ");
|
printf_filtered ("16 ");
|
break;
|
break;
|
case MEM_WIDTH_32:
|
case MEM_WIDTH_32:
|
printf_filtered ("32 ");
|
printf_filtered ("32 ");
|
break;
|
break;
|
case MEM_WIDTH_64:
|
case MEM_WIDTH_64:
|
printf_filtered ("64 ");
|
printf_filtered ("64 ");
|
break;
|
break;
|
case MEM_WIDTH_UNSPECIFIED:
|
case MEM_WIDTH_UNSPECIFIED:
|
break;
|
break;
|
}
|
}
|
|
|
#if 0
|
#if 0
|
if (attrib->hwbreak)
|
if (attrib->hwbreak)
|
printf_filtered ("hwbreak");
|
printf_filtered ("hwbreak");
|
else
|
else
|
printf_filtered ("swbreak");
|
printf_filtered ("swbreak");
|
#endif
|
#endif
|
|
|
if (attrib->cache)
|
if (attrib->cache)
|
printf_filtered ("cache ");
|
printf_filtered ("cache ");
|
else
|
else
|
printf_filtered ("nocache ");
|
printf_filtered ("nocache ");
|
|
|
#if 0
|
#if 0
|
if (attrib->verify)
|
if (attrib->verify)
|
printf_filtered ("verify ");
|
printf_filtered ("verify ");
|
else
|
else
|
printf_filtered ("noverify ");
|
printf_filtered ("noverify ");
|
#endif
|
#endif
|
|
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
|
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Enable the memory region number NUM. */
|
/* Enable the memory region number NUM. */
|
|
|
static void
|
static void
|
mem_enable (int num)
|
mem_enable (int num)
|
{
|
{
|
struct mem_region *m;
|
struct mem_region *m;
|
|
|
for (m = mem_region_chain; m; m = m->next)
|
for (m = mem_region_chain; m; m = m->next)
|
if (m->number == num)
|
if (m->number == num)
|
{
|
{
|
m->status = enabled;
|
m->status = enabled;
|
return;
|
return;
|
}
|
}
|
printf_unfiltered ("No memory region number %d.\n", num);
|
printf_unfiltered ("No memory region number %d.\n", num);
|
}
|
}
|
|
|
static void
|
static void
|
mem_enable_command (char *args, int from_tty)
|
mem_enable_command (char *args, int from_tty)
|
{
|
{
|
char *p = args;
|
char *p = args;
|
char *p1;
|
char *p1;
|
int num;
|
int num;
|
struct mem_region *m;
|
struct mem_region *m;
|
|
|
dcache_invalidate (target_dcache);
|
dcache_invalidate (target_dcache);
|
|
|
if (p == 0)
|
if (p == 0)
|
{
|
{
|
for (m = mem_region_chain; m; m = m->next)
|
for (m = mem_region_chain; m; m = m->next)
|
m->status = enabled;
|
m->status = enabled;
|
}
|
}
|
else
|
else
|
while (*p)
|
while (*p)
|
{
|
{
|
p1 = p;
|
p1 = p;
|
while (*p1 >= '0' && *p1 <= '9')
|
while (*p1 >= '0' && *p1 <= '9')
|
p1++;
|
p1++;
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
error ("Arguments must be memory region numbers.");
|
error ("Arguments must be memory region numbers.");
|
|
|
num = atoi (p);
|
num = atoi (p);
|
mem_enable (num);
|
mem_enable (num);
|
|
|
p = p1;
|
p = p1;
|
while (*p == ' ' || *p == '\t')
|
while (*p == ' ' || *p == '\t')
|
p++;
|
p++;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Disable the memory region number NUM. */
|
/* Disable the memory region number NUM. */
|
|
|
static void
|
static void
|
mem_disable (int num)
|
mem_disable (int num)
|
{
|
{
|
struct mem_region *m;
|
struct mem_region *m;
|
|
|
for (m = mem_region_chain; m; m = m->next)
|
for (m = mem_region_chain; m; m = m->next)
|
if (m->number == num)
|
if (m->number == num)
|
{
|
{
|
m->status = disabled;
|
m->status = disabled;
|
return;
|
return;
|
}
|
}
|
printf_unfiltered ("No memory region number %d.\n", num);
|
printf_unfiltered ("No memory region number %d.\n", num);
|
}
|
}
|
|
|
static void
|
static void
|
mem_disable_command (char *args, int from_tty)
|
mem_disable_command (char *args, int from_tty)
|
{
|
{
|
char *p = args;
|
char *p = args;
|
char *p1;
|
char *p1;
|
int num;
|
int num;
|
struct mem_region *m;
|
struct mem_region *m;
|
|
|
dcache_invalidate (target_dcache);
|
dcache_invalidate (target_dcache);
|
|
|
if (p == 0)
|
if (p == 0)
|
{
|
{
|
for (m = mem_region_chain; m; m = m->next)
|
for (m = mem_region_chain; m; m = m->next)
|
m->status = disabled;
|
m->status = disabled;
|
}
|
}
|
else
|
else
|
while (*p)
|
while (*p)
|
{
|
{
|
p1 = p;
|
p1 = p;
|
while (*p1 >= '0' && *p1 <= '9')
|
while (*p1 >= '0' && *p1 <= '9')
|
p1++;
|
p1++;
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
error ("Arguments must be memory region numbers.");
|
error ("Arguments must be memory region numbers.");
|
|
|
num = atoi (p);
|
num = atoi (p);
|
mem_disable (num);
|
mem_disable (num);
|
|
|
p = p1;
|
p = p1;
|
while (*p == ' ' || *p == '\t')
|
while (*p == ' ' || *p == '\t')
|
p++;
|
p++;
|
}
|
}
|
}
|
}
|
|
|
/* Clear memory region list */
|
/* Clear memory region list */
|
|
|
static void
|
static void
|
mem_clear (void)
|
mem_clear (void)
|
{
|
{
|
struct mem_region *m;
|
struct mem_region *m;
|
|
|
while ((m = mem_region_chain) != 0)
|
while ((m = mem_region_chain) != 0)
|
{
|
{
|
mem_region_chain = m->next;
|
mem_region_chain = m->next;
|
delete_mem_region (m);
|
delete_mem_region (m);
|
}
|
}
|
}
|
}
|
|
|
/* Delete the memory region number NUM. */
|
/* Delete the memory region number NUM. */
|
|
|
static void
|
static void
|
mem_delete (int num)
|
mem_delete (int num)
|
{
|
{
|
struct mem_region *m1, *m;
|
struct mem_region *m1, *m;
|
|
|
if (!mem_region_chain)
|
if (!mem_region_chain)
|
{
|
{
|
printf_unfiltered ("No memory region number %d.\n", num);
|
printf_unfiltered ("No memory region number %d.\n", num);
|
return;
|
return;
|
}
|
}
|
|
|
if (mem_region_chain->number == num)
|
if (mem_region_chain->number == num)
|
{
|
{
|
m1 = mem_region_chain;
|
m1 = mem_region_chain;
|
mem_region_chain = m1->next;
|
mem_region_chain = m1->next;
|
delete_mem_region (m1);
|
delete_mem_region (m1);
|
}
|
}
|
else
|
else
|
for (m = mem_region_chain; m->next; m = m->next)
|
for (m = mem_region_chain; m->next; m = m->next)
|
{
|
{
|
if (m->next->number == num)
|
if (m->next->number == num)
|
{
|
{
|
m1 = m->next;
|
m1 = m->next;
|
m->next = m1->next;
|
m->next = m1->next;
|
delete_mem_region (m1);
|
delete_mem_region (m1);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
mem_delete_command (char *args, int from_tty)
|
mem_delete_command (char *args, int from_tty)
|
{
|
{
|
char *p = args;
|
char *p = args;
|
char *p1;
|
char *p1;
|
int num;
|
int num;
|
|
|
dcache_invalidate (target_dcache);
|
dcache_invalidate (target_dcache);
|
|
|
if (p == 0)
|
if (p == 0)
|
{
|
{
|
if (query ("Delete all memory regions? "))
|
if (query ("Delete all memory regions? "))
|
mem_clear ();
|
mem_clear ();
|
dont_repeat ();
|
dont_repeat ();
|
return;
|
return;
|
}
|
}
|
|
|
while (*p)
|
while (*p)
|
{
|
{
|
p1 = p;
|
p1 = p;
|
while (*p1 >= '0' && *p1 <= '9')
|
while (*p1 >= '0' && *p1 <= '9')
|
p1++;
|
p1++;
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
if (*p1 && *p1 != ' ' && *p1 != '\t')
|
error ("Arguments must be memory region numbers.");
|
error ("Arguments must be memory region numbers.");
|
|
|
num = atoi (p);
|
num = atoi (p);
|
mem_delete (num);
|
mem_delete (num);
|
|
|
p = p1;
|
p = p1;
|
while (*p == ' ' || *p == '\t')
|
while (*p == ' ' || *p == '\t')
|
p++;
|
p++;
|
}
|
}
|
|
|
dont_repeat ();
|
dont_repeat ();
|
}
|
}
|
|
|
void
|
void
|
_initialize_mem ()
|
_initialize_mem ()
|
{
|
{
|
add_com ("mem", class_vars, mem_command,
|
add_com ("mem", class_vars, mem_command,
|
"Define attributes for memory region.");
|
"Define attributes for memory region.");
|
|
|
add_cmd ("mem", class_vars, mem_enable_command,
|
add_cmd ("mem", class_vars, mem_enable_command,
|
"Enable memory region.\n\
|
"Enable memory region.\n\
|
Arguments are the code numbers of the memory regions to enable.\n\
|
Arguments are the code numbers of the memory regions to enable.\n\
|
Do \"info mem\" to see current list of code numbers.", &enablelist);
|
Do \"info mem\" to see current list of code numbers.", &enablelist);
|
|
|
add_cmd ("mem", class_vars, mem_disable_command,
|
add_cmd ("mem", class_vars, mem_disable_command,
|
"Disable memory region.\n\
|
"Disable memory region.\n\
|
Arguments are the code numbers of the memory regions to disable.\n\
|
Arguments are the code numbers of the memory regions to disable.\n\
|
Do \"info mem\" to see current list of code numbers.", &disablelist);
|
Do \"info mem\" to see current list of code numbers.", &disablelist);
|
|
|
add_cmd ("mem", class_vars, mem_delete_command,
|
add_cmd ("mem", class_vars, mem_delete_command,
|
"Delete memory region.\n\
|
"Delete memory region.\n\
|
Arguments are the code numbers of the memory regions to delete.\n\
|
Arguments are the code numbers of the memory regions to delete.\n\
|
Do \"info mem\" to see current list of code numbers.", &deletelist);
|
Do \"info mem\" to see current list of code numbers.", &deletelist);
|
|
|
add_info ("mem", mem_info_command,
|
add_info ("mem", mem_info_command,
|
"Memory region attributes");
|
"Memory region attributes");
|
}
|
}
|
|
|
