gdb/memattr.c

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