1 /* Memory attributes support, for GDB.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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/>. */
29 #include "gdb_string.h"
31 const struct mem_attrib default_mem_attrib =
34 MEM_WIDTH_UNSPECIFIED,
38 -1 /* Flash blocksize not specified. */
41 const struct mem_attrib unknown_mem_attrib =
44 MEM_WIDTH_UNSPECIFIED,
48 -1 /* Flash blocksize not specified. */
52 VEC(mem_region_s) *mem_region_list, *target_mem_region_list;
53 static int mem_number = 0;
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;
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;
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;
71 show_inaccessible_by_default (struct ui_file *file, int from_tty,
72 struct cmd_list_element *c,
75 if (inaccessible_by_default)
76 fprintf_filtered (file, _("\
77 Unknown memory addresses will be treated as inaccessible.\n"));
79 fprintf_filtered (file, _("\
80 Unknown memory addresses will be treated as RAM.\n"));
84 /* Predicate function which returns true if LHS should sort before RHS
85 in a list of memory regions, useful for VEC_lower_bound. */
88 mem_region_lessthan (const struct mem_region *lhs,
89 const struct mem_region *rhs)
91 return lhs->lo < rhs->lo;
94 /* A helper function suitable for qsort, used to sort a
95 VEC(mem_region_s) by starting address. */
98 mem_region_cmp (const void *untyped_lhs, const void *untyped_rhs)
100 const struct mem_region *lhs = untyped_lhs;
101 const struct mem_region *rhs = untyped_rhs;
103 if (lhs->lo < rhs->lo)
105 else if (lhs->lo == rhs->lo)
111 /* Allocate a new memory region, with default settings. */
114 mem_region_init (struct mem_region *new)
116 memset (new, 0, sizeof (struct mem_region));
118 new->attrib = default_mem_attrib;
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. */
126 require_user_regions (int from_tty)
128 struct mem_region *m;
131 /* If we're already using a user-provided list, nothing to do. */
135 /* Switch to a user-provided list (possibly a copy of the current
139 /* If we don't have a target-provided region list yet, then
141 if (mem_region_list == NULL)
144 /* Otherwise, let the user know how to get back. */
146 warning (_("Switching to manual control of memory regions; use "
147 "\"mem auto\" to fetch regions from the target again."));
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);
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. */
162 require_target_regions (void)
164 if (mem_use_target && !target_mem_regions_valid)
166 target_mem_regions_valid = 1;
167 target_mem_region_list = target_memory_map ();
168 mem_region_list = target_mem_region_list;
173 create_mem_region (CORE_ADDR lo, CORE_ADDR hi,
174 const struct mem_attrib *attrib)
176 struct mem_region new;
179 /* lo == hi is a useless empty region */
180 if (lo >= hi && hi != 0)
182 printf_unfiltered (_("invalid memory region: low >= high\n"));
186 mem_region_init (&new);
190 ix = VEC_lower_bound (mem_region_s, mem_region_list, &new,
191 mem_region_lessthan);
193 /* Check for an overlapping memory region. We only need to check
194 in the vicinity - at most one before and one after the
196 for (i = ix - 1; i < ix + 1; i++)
198 struct mem_region *n;
202 if (i >= VEC_length (mem_region_s, mem_region_list))
205 n = VEC_index (mem_region_s, mem_region_list, i);
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)))
211 printf_unfiltered (_("overlapping memory region\n"));
216 new.number = ++mem_number;
217 new.attrib = *attrib;
218 VEC_safe_insert (mem_region_s, mem_region_list, ix, &new);
222 * Look up the memory region cooresponding to ADDR.
225 lookup_mem_region (CORE_ADDR addr)
227 static struct mem_region region;
228 struct mem_region *m;
233 require_target_regions ();
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. */
246 /* Either find memory range containing ADDRESS, or set LO and HI
247 to the nearest boundaries of an existing memory range.
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
252 for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
254 if (m->enabled_p == 1)
256 /* If the address is in the memory region, return that memory range. */
257 if (addr >= m->lo && (addr < m->hi || m->hi == 0))
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)
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))
274 /* Because no region was found, we must cons up one based on what
275 was learned above. */
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;
285 region.attrib = default_mem_attrib;
290 /* Invalidate any memory regions fetched from the target. */
293 invalidate_target_mem_regions (void)
295 if (!target_mem_regions_valid)
298 target_mem_regions_valid = 0;
299 VEC_free (mem_region_s, target_mem_region_list);
301 mem_region_list = NULL;
304 /* Clear memory region list */
309 VEC_free (mem_region_s, mem_region_list);
314 mem_command (char *args, int from_tty)
318 struct mem_attrib attrib;
321 error_no_arg (_("No mem"));
323 /* For "mem auto", switch back to using a target provided list. */
324 if (strcmp (args, "auto") == 0)
329 if (mem_region_list != target_mem_region_list)
332 mem_region_list = target_mem_region_list;
339 require_user_regions (from_tty);
341 tok = strtok (args, " \t");
343 error (_("no lo address"));
344 lo = parse_and_eval_address (tok);
346 tok = strtok (NULL, " \t");
348 error (_("no hi address"));
349 hi = parse_and_eval_address (tok);
351 attrib = default_mem_attrib;
352 while ((tok = strtok (NULL, " \t")) != NULL)
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;
361 else if (strcmp (tok, "8") == 0)
362 attrib.width = MEM_WIDTH_8;
363 else if (strcmp (tok, "16") == 0)
365 if ((lo % 2 != 0) || (hi % 2 != 0))
366 error (_("region bounds not 16 bit aligned"));
367 attrib.width = MEM_WIDTH_16;
369 else if (strcmp (tok, "32") == 0)
371 if ((lo % 4 != 0) || (hi % 4 != 0))
372 error (_("region bounds not 32 bit aligned"));
373 attrib.width = MEM_WIDTH_32;
375 else if (strcmp (tok, "64") == 0)
377 if ((lo % 8 != 0) || (hi % 8 != 0))
378 error (_("region bounds not 64 bit aligned"));
379 attrib.width = MEM_WIDTH_64;
383 else if (strcmp (tok, "hwbreak") == 0)
385 else if (strcmp (tok, "swbreak") == 0)
389 else if (strcmp (tok, "cache") == 0)
391 else if (strcmp (tok, "nocache") == 0)
395 else if (strcmp (tok, "verify") == 0)
397 else if (strcmp (tok, "noverify") == 0)
402 error (_("unknown attribute: %s"), tok);
405 create_mem_region (lo, hi, &attrib);
410 mem_info_command (char *args, int from_tty)
412 struct mem_region *m;
413 struct mem_attrib *attrib;
417 printf_filtered (_("Using memory regions provided by the target.\n"));
419 printf_filtered (_("Using user-defined memory regions.\n"));
421 require_target_regions ();
423 if (!mem_region_list)
425 printf_unfiltered (_("There are no memory regions defined.\n"));
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");
440 for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
443 printf_filtered ("%-3d %-3c\t",
445 m->enabled_p ? 'y' : 'n');
446 if (gdbarch_addr_bit (target_gdbarch) <= 32)
447 tmp = hex_string_custom ((unsigned long) m->lo, 8);
449 tmp = hex_string_custom ((unsigned long) m->lo, 16);
451 printf_filtered ("%s ", tmp);
453 if (gdbarch_addr_bit (target_gdbarch) <= 32)
458 tmp = hex_string_custom ((unsigned long) m->hi, 8);
463 tmp = "0x10000000000000000";
465 tmp = hex_string_custom ((unsigned long) m->hi, 16);
468 printf_filtered ("%s ", tmp);
470 /* Print a token for each attribute.
472 * FIXME: Should we output a comma after each token? It may
473 * make it easier for users to read, but we'd lose the ability
474 * to cut-and-paste the list of attributes when defining a new
475 * region. Perhaps that is not important.
477 * FIXME: If more attributes are added to GDB, the output may
478 * become cluttered and difficult for users to read. At that
479 * time, we may want to consider printing tokens only if they
480 * are different from the default attribute. */
483 switch (attrib->mode)
486 printf_filtered ("rw ");
489 printf_filtered ("ro ");
492 printf_filtered ("wo ");
495 printf_filtered ("flash blocksize 0x%x ", attrib->blocksize);
499 switch (attrib->width)
502 printf_filtered ("8 ");
505 printf_filtered ("16 ");
508 printf_filtered ("32 ");
511 printf_filtered ("64 ");
513 case MEM_WIDTH_UNSPECIFIED:
519 printf_filtered ("hwbreak");
521 printf_filtered ("swbreak");
525 printf_filtered ("cache ");
527 printf_filtered ("nocache ");
531 printf_filtered ("verify ");
533 printf_filtered ("noverify ");
536 printf_filtered ("\n");
538 gdb_flush (gdb_stdout);
543 /* Enable the memory region number NUM. */
548 struct mem_region *m;
551 for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
552 if (m->number == num)
557 printf_unfiltered (_("No memory region number %d.\n"), num);
561 mem_enable_command (char *args, int from_tty)
566 struct mem_region *m;
569 require_user_regions (from_tty);
571 target_dcache_invalidate ();
575 for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
582 while (*p1 >= '0' && *p1 <= '9')
584 if (*p1 && *p1 != ' ' && *p1 != '\t')
585 error (_("Arguments must be memory region numbers."));
591 while (*p == ' ' || *p == '\t')
597 /* Disable the memory region number NUM. */
600 mem_disable (int num)
602 struct mem_region *m;
605 for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
606 if (m->number == num)
611 printf_unfiltered (_("No memory region number %d.\n"), num);
615 mem_disable_command (char *args, int from_tty)
620 struct mem_region *m;
623 require_user_regions (from_tty);
625 target_dcache_invalidate ();
629 for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
636 while (*p1 >= '0' && *p1 <= '9')
638 if (*p1 && *p1 != ' ' && *p1 != '\t')
639 error (_("Arguments must be memory region numbers."));
645 while (*p == ' ' || *p == '\t')
650 /* Delete the memory region number NUM. */
655 struct mem_region *m;
658 if (!mem_region_list)
660 printf_unfiltered (_("No memory region number %d.\n"), num);
664 for (ix = 0; VEC_iterate (mem_region_s, mem_region_list, ix, m); ix++)
665 if (m->number == num)
670 printf_unfiltered (_("No memory region number %d.\n"), num);
674 VEC_ordered_remove (mem_region_s, mem_region_list, ix);
678 mem_delete_command (char *args, int from_tty)
684 require_user_regions (from_tty);
686 target_dcache_invalidate ();
690 if (query (_("Delete all memory regions? ")))
699 while (*p1 >= '0' && *p1 <= '9')
701 if (*p1 && *p1 != ' ' && *p1 != '\t')
702 error (_("Arguments must be memory region numbers."));
708 while (*p == ' ' || *p == '\t')
716 dummy_cmd (char *args, int from_tty)
720 extern initialize_file_ftype _initialize_mem; /* -Wmissing-prototype */
722 static struct cmd_list_element *mem_set_cmdlist;
723 static struct cmd_list_element *mem_show_cmdlist;
726 _initialize_mem (void)
728 add_com ("mem", class_vars, mem_command, _("\
729 Define attributes for memory region or reset memory region handling to\n\
732 mem <lo addr> <hi addr> [<mode> <width> <cache>], \n\
733 where <mode> may be rw (read/write), ro (read-only) or wo (write-only), \n\
734 <width> may be 8, 16, 32, or 64, and \n\
735 <cache> may be cache or nocache"));
737 add_cmd ("mem", class_vars, mem_enable_command, _("\
738 Enable memory region.\n\
739 Arguments are the code numbers of the memory regions to enable.\n\
740 Usage: enable mem <code number>\n\
741 Do \"info mem\" to see current list of code numbers."), &enablelist);
743 add_cmd ("mem", class_vars, mem_disable_command, _("\
744 Disable memory region.\n\
745 Arguments are the code numbers of the memory regions to disable.\n\
746 Usage: disable mem <code number>\n\
747 Do \"info mem\" to see current list of code numbers."), &disablelist);
749 add_cmd ("mem", class_vars, mem_delete_command, _("\
750 Delete memory region.\n\
751 Arguments are the code numbers of the memory regions to delete.\n\
752 Usage: delete mem <code number>\n\
753 Do \"info mem\" to see current list of code numbers."), &deletelist);
755 add_info ("mem", mem_info_command,
756 _("Memory region attributes"));
758 add_prefix_cmd ("mem", class_vars, dummy_cmd, _("\
759 Memory regions settings"),
760 &mem_set_cmdlist, "set mem ",
761 0/* allow-unknown */, &setlist);
762 add_prefix_cmd ("mem", class_vars, dummy_cmd, _("\
763 Memory regions settings"),
764 &mem_show_cmdlist, "show mem ",
765 0/* allow-unknown */, &showlist);
767 add_setshow_boolean_cmd ("inaccessible-by-default", no_class,
768 &inaccessible_by_default, _("\
769 Set handling of unknown memory regions."), _("\
770 Show handling of unknown memory regions."), _("\
771 If on, and some memory map is defined, debugger will emit errors on\n\
772 accesses to memory not defined in the memory map. If off, accesses to all\n\
773 memory addresses will be allowed."),
775 show_inaccessible_by_default,