1 /* Memory attributes support, for GDB. 2 3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 4 2011 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 #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 || 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 ®ion; 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 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 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 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 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 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 } 759