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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [memattr.c] - Blame information for rev 1782

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


/* 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"
 
/* 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 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->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)
{
  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->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;
}
 
 
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);
}
 
 
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);
    }
}
 
 
/* 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++;
      }
}
 
 
/* 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 ();
}
 
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");
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [memattr.c] - Blame information for rev 1782

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