gdb/memattr.c

   1 /* Memory attributes support, for GDB.
   2
   3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  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 "vec.h"
  29 #include "gdb_string.h"
  30
  31 const struct mem_attrib default_mem_attrib =
  32 {
  33   MEM_RW,                       /* mode */
  34   MEM_WIDTH_UNSPECIFIED,
  35   0,                            /* hwbreak */
  36   0,                            /* cache */
  37   0,                            /* verify */
  38   -1 /* Flash blocksize not specified.  */
  39 };
  40
  41 const struct mem_attrib unknown_mem_attrib =
  42 {
  43   MEM_NONE,                     /* mode */
  44   MEM_WIDTH_UNSPECIFIED,
  45   0,                            /* hwbreak */
  46   0,                            /* cache */
  47   0,                            /* verify */
  48   -1 /* Flash blocksize not specified.  */
  49 };
  50
  51
  52 VEC(mem_region_s) *mem_region_list, *target_mem_region_list;
  53 static int mem_number = 0;
  54
  55 /* If this flag is set, the memory region list should be automatically
  56    updated from the target.  If it is clear, the list is user-controlled
  57    and should be left alone.  */
  58 static int mem_use_target = 1;
  59
  60 /* If this flag is set, we have tried to fetch the target memory regions
  61    since the last time it was invalidated.  If that list is still
  62    empty, then the target can't supply memory regions.  */
  63 static int target_mem_regions_valid;
  64
  65 /* If this flag is set, gdb will assume that memory ranges not
  66    specified by the memory map have type MEM_NONE, and will
  67    emit errors on all accesses to that memory.  */
  68 static int inaccessible_by_default = 1;
  69
  70 static void
  71 show_inaccessible_by_default (struct ui_file *file, int from_tty,
  72                               struct cmd_list_element *c,
  73                               const char *value)
  74 {
  75   if (inaccessible_by_default)
  76     fprintf_filtered (file, _("\
  77 Unknown memory addresses will be treated as inaccessible.\n"));
  78   else
  79     fprintf_filtered (file, _("\
  80 Unknown memory addresses will be treated as RAM.\n"));
  81 }
  82
  83
  84 /* Predicate function which returns true if LHS should sort before RHS
  85    in a list of memory regions, useful for VEC_lower_bound.  */
  86
  87 static int
  88 mem_region_lessthan (const struct mem_region *lhs,
  89                      const struct mem_region *rhs)
  90 {
  91   return lhs->lo < rhs->lo;
  92 }
  93
  94 /* A helper function suitable for qsort, used to sort a
  95    VEC(mem_region_s) by starting address.  */
  96
  97 int
  98 mem_region_cmp (const void *untyped_lhs, const void *untyped_rhs)
  99 {
 100   const struct mem_region *lhs = untyped_lhs;
 101   const struct mem_region *rhs = untyped_rhs;
 102
 103   if (lhs->lo < rhs->lo)
 104     return -1;
 105   else if (lhs->lo == rhs->lo)
 106     return 0;
 107   else
 108     return 1;
 109 }
 110
 111 /* Allocate a new memory region, with default settings.  */
 112
 113 void
 114 mem_region_init (struct mem_region *new)
 115 {
 116   memset (new, 0, sizeof (struct mem_region));
 117   new->enabled_p = 1;
 118   new->attrib = default_mem_attrib;
 119 }
 120
 121 /* This function should be called before any command which would
 122    modify the memory region list.  It will handle switching from
 123    a target-provided list to a local list, if necessary.  */
 124
 125 static void
 126 require_user_regions (int from_tty)
 127 {
 128   struct mem_region *m;
 129   int ix, length;
 130
 131   /* If we're already using a user-provided list, nothing to do.  */
 132   if (!mem_use_target)
 133     return;
 134
 135   /* Switch to a user-provided list (possibly a copy of the current
 136      one).  */
 137   mem_use_target = 0;
 138
 139   /* If we don't have a target-provided region list yet, then
 140      no need to warn.  */
 141   if (mem_region_list == NULL)
 142     return;
 143
 144   /* Otherwise, let the user know how to get back.  */
 145   if (from_tty)
 146     warning (_("Switching to manual control of memory regions; use "
 147                "\"mem auto\" to fetch regions from the target again."));
 148
 149   /* And create a new list for the user to modify.  */
 150   length = VEC_length (mem_region_s, target_mem_region_list);
 151   mem_region_list = VEC_alloc (mem_region_s, length);
 152   for (ix = 0; VEC_iterate (mem_region_s, target_mem_region_list, ix, m); ix++)
 153     VEC_quick_push (mem_region_s, mem_region_list, m);
 154 }
 155
 156 /* This function should be called before any command which would
 157    read the memory region list, other than those which call
 158    require_user_regions.  It will handle fetching the
 159    target-provided list, if necessary.  */
 160
 161 static void
 162 require_target_regions (void)
 163 {
 164   if (mem_use_target && !target_mem_regions_valid)
 165     {
 166       target_mem_regions_valid = 1;
 167       target_mem_region_list = target_memory_map ();
 168       mem_region_list = target_mem_region_list;
 169     }
 170 }
 171
 172 static void
 173 create_mem_region (CORE_ADDR lo, CORE_ADDR hi,
 174                    const struct mem_attrib *attrib)
 175 {
 176   struct mem_region new;
 177   int i, ix;
 178
 179   /* lo == hi is a useless empty region */
 180   if (lo >= hi && hi != 0)
 181     {
 182       printf_unfiltered (_("invalid memory region: low >= high\n"));
 183       return;
 184     }
 185
 186   mem_region_init (&new);
 187   new.lo = lo;
 188   new.hi = hi;
 189
 190   ix = VEC_lower_bound (mem_region_s, mem_region_list, &new,
 191                         mem_region_lessthan);
 192
 193   /* Check for an overlapping memory region.  We only need to check
 194      in the vicinity - at most one before and one after the
 195      insertion point.  */
 196   for (i = ix - 1; i < ix + 1; i++)
 197     {
 198       struct mem_region *n;
 199
 200       if (i < 0)
 201         continue;
 202       if (i >= VEC_length (mem_region_s, mem_region_list))
 203         continue;
 204
 205       n = VEC_index (mem_region_s, mem_region_list, i);
 206
 207       if ((lo >= n->lo && (lo < n->hi || n->hi == 0))
 208           || (hi > n->lo && (hi <= n->hi || n->hi == 0))
 209           || (lo <= n->lo && (hi >= n->hi || hi == 0)))
 210         {
 211           printf_unfiltered (_("overlapping memory region\n"));
 212           return;
 213         }
 214     }
 215
 216   new.number = ++mem_number;
 217   new.attrib = *attrib;
 218   VEC_safe_insert (mem_region_s, mem_region_list, ix, &new);
 219 }
 220
 221 /*
 222  * Look up the memory region cooresponding to ADDR.
 223  */
 224 struct mem_region *
 225 lookup_mem_region (CORE_ADDR addr)
 226 {
 227   static struct mem_region region;
 228   struct mem_region *m;
 229   CORE_ADDR lo;
 230   CORE_ADDR hi;
 231   int ix;
 232
 233   require_target_regions ();
 234
 235   /* First we initialize LO and HI so that they describe the entire
 236      memory space.  As we process the memory region chain, they are
 237      redefined to describe the minimal region containing ADDR.  LO
 238      and HI are used in the case where no memory region is defined
 239      that contains ADDR.  If a memory region is disabled, it is
 240      treated as if it does not exist.  The initial values for LO
 241      and HI represent the bottom and top of memory.  */
 242
 243   lo = 0;
 244   hi = 0;
 245
 246   /* Either find memory range containing ADDRESS, or set LO and HI
 247      to the nearest boundaries of an existing memory range.
 248
 249      If we ever want to support a huge list of memory regions, this
 250      check should be replaced with a binary search (probably using
 251      VEC_lower_bound).  */
 252   for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
 253     {
 254       if (m->enabled_p == 1)
 255         {
 256           /* If the address is in the memory region, return that memory range.  */
 257           if (addr >= m->lo && (addr < m->hi || m->hi == 0))
 258             return m;
 259
 260           /* This (correctly) won't match if m->hi == 0, representing
 261              the top of the address space, because CORE_ADDR is unsigned;
 262              no value of LO is less than zero.  */
 263           if (addr >= m->hi && lo < m->hi)
 264             lo = m->hi;
 265
 266           /* This will never set HI to zero; if we're here and ADDR
 267              is at or below M, and the region starts at zero, then ADDR
 268              would have been in the region.  */
 269           if (addr <= m->lo && (hi == 0 || hi > m->lo))
 270             hi = m->lo;
 271         }
 272     }
 273
 274   /* Because no region was found, we must cons up one based on what
 275      was learned above.  */
 276   region.lo = lo;
 277   region.hi = hi;
 278
 279   /* When no memory map is defined at all, we always return
 280      'default_mem_attrib', so that we do not make all memory
 281      inaccessible for targets that don't provide a memory map.  */
 282   if (inaccessible_by_default && !VEC_empty (mem_region_s, mem_region_list))
 283     region.attrib = unknown_mem_attrib;
 284   else
 285     region.attrib = default_mem_attrib;
 286
 287   return &region;
 288 }
 289
 290 /* Invalidate any memory regions fetched from the target.  */
 291
 292 void
 293 invalidate_target_mem_regions (void)
 294 {
 295   if (!target_mem_regions_valid)
 296     return;
 297
 298   target_mem_regions_valid = 0;
 299   VEC_free (mem_region_s, target_mem_region_list);
 300   if (mem_use_target)
 301     mem_region_list = NULL;
 302 }
 303
 304 /* Clear memory region list */
 305
 306 static void
 307 mem_clear (void)
 308 {
 309   VEC_free (mem_region_s, mem_region_list);
 310 }
 311 \f
 312
 313 static void
 314 mem_command (char *args, int from_tty)
 315 {
 316   CORE_ADDR lo, hi;
 317   char *tok;
 318   struct mem_attrib attrib;
 319
 320   if (!args)
 321     error_no_arg (_("No mem"));
 322
 323   /* For "mem auto", switch back to using a target provided list.  */
 324   if (strcmp (args, "auto") == 0)
 325     {
 326       if (mem_use_target)
 327         return;
 328
 329       if (mem_region_list != target_mem_region_list)
 330         {
 331           mem_clear ();
 332           mem_region_list = target_mem_region_list;
 333         }
 334
 335       mem_use_target = 1;
 336       return;
 337     }
 338
 339   require_user_regions (from_tty);
 340
 341   tok = strtok (args, " \t");
 342   if (!tok)
 343     error (_("no lo address"));
 344   lo = parse_and_eval_address (tok);
 345
 346   tok = strtok (NULL, " \t");
 347   if (!tok)
 348     error (_("no hi address"));
 349   hi = parse_and_eval_address (tok);
 350
 351   attrib = default_mem_attrib;
 352   while ((tok = strtok (NULL, " \t")) != NULL)
 353     {
 354       if (strcmp (tok, "rw") == 0)
 355         attrib.mode = MEM_RW;
 356       else if (strcmp (tok, "ro") == 0)
 357         attrib.mode = MEM_RO;
 358       else if (strcmp (tok, "wo") == 0)
 359         attrib.mode = MEM_WO;
 360
 361       else if (strcmp (tok, "8") == 0)
 362         attrib.width = MEM_WIDTH_8;
 363       else if (strcmp (tok, "16") == 0)
 364         {
 365           if ((lo % 2 != 0) || (hi % 2 != 0))
 366             error (_("region bounds not 16 bit aligned"));
 367           attrib.width = MEM_WIDTH_16;
 368         }
 369       else if (strcmp (tok, "32") == 0)
 370         {
 371           if ((lo % 4 != 0) || (hi % 4 != 0))
 372             error (_("region bounds not 32 bit aligned"));
 373           attrib.width = MEM_WIDTH_32;
 374         }
 375       else if (strcmp (tok, "64") == 0)
 376         {
 377           if ((lo % 8 != 0) || (hi % 8 != 0))
 378             error (_("region bounds not 64 bit aligned"));
 379           attrib.width = MEM_WIDTH_64;
 380         }
 381
 382 #if 0
 383       else if (strcmp (tok, "hwbreak") == 0)
 384         attrib.hwbreak = 1;
 385       else if (strcmp (tok, "swbreak") == 0)
 386         attrib.hwbreak = 0;
 387 #endif
 388
 389       else if (strcmp (tok, "cache") == 0)
 390         attrib.cache = 1;
 391       else if (strcmp (tok, "nocache") == 0)
 392         attrib.cache = 0;
 393
 394 #if 0
 395       else if (strcmp (tok, "verify") == 0)
 396         attrib.verify = 1;
 397       else if (strcmp (tok, "noverify") == 0)
 398         attrib.verify = 0;
 399 #endif
 400
 401       else
 402         error (_("unknown attribute: %s"), tok);
 403     }
 404
 405   create_mem_region (lo, hi, &attrib);
 406 }
 407 \f
 408
 409 static void
 410 mem_info_command (char *args, int from_tty)
 411 {
 412   struct mem_region *m;
 413   struct mem_attrib *attrib;
 414   int ix;
 415
 416   if (mem_use_target)
 417     printf_filtered (_("Using memory regions provided by the target.\n"));
 418   else
 419     printf_filtered (_("Using user-defined memory regions.\n"));
 420
 421   require_target_regions ();
 422
 423   if (!mem_region_list)
 424     {
 425       printf_unfiltered (_("There are no memory regions defined.\n"));
 426       return;
 427     }
 428
 429   printf_filtered ("Num ");
 430   printf_filtered ("Enb ");
 431   printf_filtered ("Low Addr   ");
 432   if (gdbarch_addr_bit (target_gdbarch) > 32)
 433     printf_filtered ("        ");
 434   printf_filtered ("High Addr  ");
 435   if (gdbarch_addr_bit (target_gdbarch) > 32)
 436     printf_filtered ("        ");
 437   printf_filtered ("Attrs ");
 438   printf_filtered ("\n");
 439
 440   for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
 441     {
 442       char *tmp;
 443
 444       printf_filtered ("%-3d %-3c\t",
 445                        m->number,
 446                        m->enabled_p ? 'y' : 'n');
 447       if (gdbarch_addr_bit (target_gdbarch) <= 32)
 448         tmp = hex_string_custom ((unsigned long) m->lo, 8);
 449       else
 450         tmp = hex_string_custom ((unsigned long) m->lo, 16);
 451
 452       printf_filtered ("%s ", tmp);
 453
 454       if (gdbarch_addr_bit (target_gdbarch) <= 32)
 455         {
 456           if (m->hi == 0)
 457             tmp = "0x100000000";
 458           else
 459             tmp = hex_string_custom ((unsigned long) m->hi, 8);
 460         }
 461       else
 462         {
 463           if (m->hi == 0)
 464             tmp = "0x10000000000000000";
 465           else
 466             tmp = hex_string_custom ((unsigned long) m->hi, 16);
 467         }
 468
 469       printf_filtered ("%s ", tmp);
 470
 471       /* Print a token for each attribute.
 472
 473        * FIXME: Should we output a comma after each token?  It may
 474        * make it easier for users to read, but we'd lose the ability
 475        * to cut-and-paste the list of attributes when defining a new
 476        * region.  Perhaps that is not important.
 477        *
 478        * FIXME: If more attributes are added to GDB, the output may
 479        * become cluttered and difficult for users to read.  At that
 480        * time, we may want to consider printing tokens only if they
 481        * are different from the default attribute.  */
 482
 483       attrib = &m->attrib;
 484       switch (attrib->mode)
 485         {
 486         case MEM_RW:
 487           printf_filtered ("rw ");
 488           break;
 489         case MEM_RO:
 490           printf_filtered ("ro ");
 491           break;
 492         case MEM_WO:
 493           printf_filtered ("wo ");
 494           break;
 495         case MEM_FLASH:
 496           printf_filtered ("flash blocksize 0x%x ", attrib->blocksize);
 497           break;
 498         }
 499
 500       switch (attrib->width)
 501         {
 502         case MEM_WIDTH_8:
 503           printf_filtered ("8 ");
 504           break;
 505         case MEM_WIDTH_16:
 506           printf_filtered ("16 ");
 507           break;
 508         case MEM_WIDTH_32:
 509           printf_filtered ("32 ");
 510           break;
 511         case MEM_WIDTH_64:
 512           printf_filtered ("64 ");
 513           break;
 514         case MEM_WIDTH_UNSPECIFIED:
 515           break;
 516         }
 517
 518 #if 0
 519       if (attrib->hwbreak)
 520         printf_filtered ("hwbreak");
 521       else
 522         printf_filtered ("swbreak");
 523 #endif
 524
 525       if (attrib->cache)
 526         printf_filtered ("cache ");
 527       else
 528         printf_filtered ("nocache ");
 529
 530 #if 0
 531       if (attrib->verify)
 532         printf_filtered ("verify ");
 533       else
 534         printf_filtered ("noverify ");
 535 #endif
 536
 537       printf_filtered ("\n");
 538
 539       gdb_flush (gdb_stdout);
 540     }
 541 }
 542 \f
 543
 544 /* Enable the memory region number NUM. */
 545
 546 static void
 547 mem_enable (int num)
 548 {
 549   struct mem_region *m;
 550   int ix;
 551
 552   for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
 553     if (m->number == num)
 554       {
 555         m->enabled_p = 1;
 556         return;
 557       }
 558   printf_unfiltered (_("No memory region number %d.\n"), num);
 559 }
 560
 561 static void
 562 mem_enable_command (char *args, int from_tty)
 563 {
 564   char *p = args;
 565   char *p1;
 566   int num;
 567   struct mem_region *m;
 568   int ix;
 569
 570   require_user_regions (from_tty);
 571
 572   target_dcache_invalidate ();
 573
 574   if (p == 0)
 575     {
 576       for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
 577         m->enabled_p = 1;
 578     }
 579   else
 580     while (*p)
 581       {
 582         p1 = p;
 583         while (*p1 >= '0' && *p1 <= '9')
 584           p1++;
 585         if (*p1 && *p1 != ' ' && *p1 != '\t')
 586           error (_("Arguments must be memory region numbers."));
 587
 588         num = atoi (p);
 589         mem_enable (num);
 590
 591         p = p1;
 592         while (*p == ' ' || *p == '\t')
 593           p++;
 594       }
 595 }
 596 \f
 597
 598 /* Disable the memory region number NUM. */
 599
 600 static void
 601 mem_disable (int num)
 602 {
 603   struct mem_region *m;
 604   int ix;
 605
 606   for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
 607     if (m->number == num)
 608       {
 609         m->enabled_p = 0;
 610         return;
 611       }
 612   printf_unfiltered (_("No memory region number %d.\n"), num);
 613 }
 614
 615 static void
 616 mem_disable_command (char *args, int from_tty)
 617 {
 618   char *p = args;
 619   char *p1;
 620   int num;
 621   struct mem_region *m;
 622   int ix;
 623
 624   require_user_regions (from_tty);
 625
 626   target_dcache_invalidate ();
 627
 628   if (p == 0)
 629     {
 630       for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
 631         m->enabled_p = 0;
 632     }
 633   else
 634     while (*p)
 635       {
 636         p1 = p;
 637         while (*p1 >= '0' && *p1 <= '9')
 638           p1++;
 639         if (*p1 && *p1 != ' ' && *p1 != '\t')
 640           error (_("Arguments must be memory region numbers."));
 641
 642         num = atoi (p);
 643         mem_disable (num);
 644
 645         p = p1;
 646         while (*p == ' ' || *p == '\t')
 647           p++;
 648       }
 649 }
 650
 651 /* Delete the memory region number NUM. */
 652
 653 static void
 654 mem_delete (int num)
 655 {
 656   struct mem_region *m;
 657   int ix;
 658
 659   if (!mem_region_list)
 660     {
 661       printf_unfiltered (_("No memory region number %d.\n"), num);
 662       return;
 663     }
 664
 665   for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
 666     if (m->number == num)
 667       break;
 668
 669   if (m == NULL)
 670     {
 671       printf_unfiltered (_("No memory region number %d.\n"), num);
 672       return;
 673     }
 674
 675   VEC_ordered_remove (mem_region_s, mem_region_list, ix);
 676 }
 677
 678 static void
 679 mem_delete_command (char *args, int from_tty)
 680 {
 681   char *p = args;
 682   char *p1;
 683   int num;
 684
 685   require_user_regions (from_tty);
 686
 687   target_dcache_invalidate ();
 688
 689   if (p == 0)
 690     {
 691       if (query (_("Delete all memory regions? ")))
 692         mem_clear ();
 693       dont_repeat ();
 694       return;
 695     }
 696
 697   while (*p)
 698     {
 699       p1 = p;
 700       while (*p1 >= '0' && *p1 <= '9')
 701         p1++;
 702       if (*p1 && *p1 != ' ' && *p1 != '\t')
 703         error (_("Arguments must be memory region numbers."));
 704
 705       num = atoi (p);
 706       mem_delete (num);
 707
 708       p = p1;
 709       while (*p == ' ' || *p == '\t')
 710         p++;
 711     }
 712
 713   dont_repeat ();
 714 }
 715
 716 static void
 717 dummy_cmd (char *args, int from_tty)
 718 {
 719 }
 720 \f
 721 extern initialize_file_ftype _initialize_mem; /* -Wmissing-prototype */
 722
 723 static struct cmd_list_element *mem_set_cmdlist;
 724 static struct cmd_list_element *mem_show_cmdlist;
 725
 726 void
 727 _initialize_mem (void)
 728 {
 729   add_com ("mem", class_vars, mem_command, _("\
 730 Define attributes for memory region or reset memory region handling to\n\
 731 target-based.\n\
 732 Usage: mem auto\n\
 733        mem <lo addr> <hi addr> [<mode> <width> <cache>], \n\
 734 where <mode>  may be rw (read/write), ro (read-only) or wo (write-only), \n\
 735       <width> may be 8, 16, 32, or 64, and \n\
 736       <cache> may be cache or nocache"));
 737
 738   add_cmd ("mem", class_vars, mem_enable_command, _("\
 739 Enable memory region.\n\
 740 Arguments are the code numbers of the memory regions to enable.\n\
 741 Usage: enable mem <code number>\n\
 742 Do \"info mem\" to see current list of code numbers."), &enablelist);
 743
 744   add_cmd ("mem", class_vars, mem_disable_command, _("\
 745 Disable memory region.\n\
 746 Arguments are the code numbers of the memory regions to disable.\n\
 747 Usage: disable mem <code number>\n\
 748 Do \"info mem\" to see current list of code numbers."), &disablelist);
 749
 750   add_cmd ("mem", class_vars, mem_delete_command, _("\
 751 Delete memory region.\n\
 752 Arguments are the code numbers of the memory regions to delete.\n\
 753 Usage: delete mem <code number>\n\
 754 Do \"info mem\" to see current list of code numbers."), &deletelist);
 755
 756   add_info ("mem", mem_info_command,
 757             _("Memory region attributes"));
 758
 759   add_prefix_cmd ("mem", class_vars, dummy_cmd, _("\
 760 Memory regions settings"),
 761                   &mem_set_cmdlist, "set mem ",
 762                   0/* allow-unknown */, &setlist);
 763   add_prefix_cmd ("mem", class_vars, dummy_cmd, _("\
 764 Memory regions settings"),
 765                   &mem_show_cmdlist, "show mem  ",
 766                   0/* allow-unknown */, &showlist);
 767
 768   add_setshow_boolean_cmd ("inaccessible-by-default", no_class,
 769                                   &inaccessible_by_default, _("\
 770 Set handling of unknown memory regions."), _("\
 771 Show handling of unknown memory regions."), _("\
 772 If on, and some memory map is defined, debugger will emit errors on\n\
 773 accesses to memory not defined in the memory map. If off, accesses to all\n\
 774 memory addresses will be allowed."),
 775                                 NULL,
 776                                 show_inaccessible_by_default,
 777                                 &mem_set_cmdlist,
 778                                 &mem_show_cmdlist);
 779 }