gdb/memattr.c

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