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