mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-05 16:24:02 +08:00
268a13a5a3
This is the next patch in the ongoing series to move gdbsever to the top level. This patch just renames the "common" directory. The idea is to do this move in two parts: first rename the directory (this patch), then move the directory to the top. This approach makes the patches a bit more tractable. I chose the name "gdbsupport" for the directory. However, as this patch was largely written by sed, we could pick a new name without too much difficulty. Tested by the buildbot. gdb/ChangeLog 2019-07-09 Tom Tromey <tom@tromey.com> * contrib/ari/gdb_ari.sh: Change common to gdbsupport. * configure: Rebuild. * configure.ac: Change common to gdbsupport. * gdbsupport: Rename from common. * acinclude.m4: Change common to gdbsupport. * Makefile.in (CONFIG_SRC_SUBDIR, COMMON_SFILES) (HFILES_NO_SRCDIR, stamp-version, ALLDEPFILES): Change common to gdbsupport. * aarch64-tdep.c, ada-lang.c, ada-lang.h, agent.c, alloc.c, amd64-darwin-tdep.c, amd64-dicos-tdep.c, amd64-fbsd-nat.c, amd64-fbsd-tdep.c, amd64-linux-nat.c, amd64-linux-tdep.c, amd64-nbsd-tdep.c, amd64-obsd-tdep.c, amd64-sol2-tdep.c, amd64-tdep.c, amd64-windows-tdep.c, arch-utils.c, arch/aarch64-insn.c, arch/aarch64.c, arch/aarch64.h, arch/amd64.c, arch/amd64.h, arch/arm-get-next-pcs.c, arch/arm-linux.c, arch/arm.c, arch/i386.c, arch/i386.h, arch/ppc-linux-common.c, arch/riscv.c, arch/riscv.h, arch/tic6x.c, arm-tdep.c, auto-load.c, auxv.c, ax-gdb.c, ax-general.c, ax.h, breakpoint.c, breakpoint.h, btrace.c, btrace.h, build-id.c, build-id.h, c-lang.h, charset.c, charset.h, cli/cli-cmds.c, cli/cli-cmds.h, cli/cli-decode.c, cli/cli-dump.c, cli/cli-option.h, cli/cli-script.c, coff-pe-read.c, command.h, compile/compile-c-support.c, compile/compile-c.h, compile/compile-cplus-symbols.c, compile/compile-cplus-types.c, compile/compile-cplus.h, compile/compile-loc2c.c, compile/compile.c, completer.c, completer.h, contrib/ari/gdb_ari.sh, corefile.c, corelow.c, cp-support.c, cp-support.h, cp-valprint.c, csky-tdep.c, ctf.c, darwin-nat.c, debug.c, defs.h, disasm-selftests.c, disasm.c, disasm.h, dtrace-probe.c, dwarf-index-cache.c, dwarf-index-cache.h, dwarf-index-write.c, dwarf2-frame.c, dwarf2expr.c, dwarf2loc.c, dwarf2read.c, event-loop.c, event-top.c, exceptions.c, exec.c, extension.h, fbsd-nat.c, features/aarch64-core.c, features/aarch64-fpu.c, features/aarch64-pauth.c, features/aarch64-sve.c, features/i386/32bit-avx.c, features/i386/32bit-avx512.c, features/i386/32bit-core.c, features/i386/32bit-linux.c, features/i386/32bit-mpx.c, features/i386/32bit-pkeys.c, features/i386/32bit-segments.c, features/i386/32bit-sse.c, features/i386/64bit-avx.c, features/i386/64bit-avx512.c, features/i386/64bit-core.c, features/i386/64bit-linux.c, features/i386/64bit-mpx.c, features/i386/64bit-pkeys.c, features/i386/64bit-segments.c, features/i386/64bit-sse.c, features/i386/x32-core.c, features/riscv/32bit-cpu.c, features/riscv/32bit-csr.c, features/riscv/32bit-fpu.c, features/riscv/64bit-cpu.c, features/riscv/64bit-csr.c, features/riscv/64bit-fpu.c, features/tic6x-c6xp.c, features/tic6x-core.c, features/tic6x-gp.c, filename-seen-cache.h, findcmd.c, findvar.c, fork-child.c, gcore.c, gdb_bfd.c, gdb_bfd.h, gdb_proc_service.h, gdb_regex.c, gdb_select.h, gdb_usleep.c, gdbarch-selftests.c, gdbthread.h, gdbtypes.h, gnu-nat.c, go32-nat.c, guile/guile.c, guile/scm-ports.c, guile/scm-safe-call.c, guile/scm-type.c, i386-fbsd-nat.c, i386-fbsd-tdep.c, i386-go32-tdep.c, i386-linux-nat.c, i386-linux-tdep.c, i386-tdep.c, i387-tdep.c, ia64-libunwind-tdep.c, ia64-linux-nat.c, inf-child.c, inf-ptrace.c, infcall.c, infcall.h, infcmd.c, inferior-iter.h, inferior.c, inferior.h, inflow.c, inflow.h, infrun.c, infrun.h, inline-frame.c, language.h, linespec.c, linux-fork.c, linux-nat.c, linux-tdep.c, linux-thread-db.c, location.c, machoread.c, macrotab.h, main.c, maint.c, maint.h, memattr.c, memrange.h, mi/mi-cmd-break.h, mi/mi-cmd-env.c, mi/mi-cmd-stack.c, mi/mi-cmd-var.c, mi/mi-interp.c, mi/mi-main.c, mi/mi-parse.h, minsyms.c, mips-linux-tdep.c, namespace.h, nat/aarch64-linux-hw-point.c, nat/aarch64-linux-hw-point.h, nat/aarch64-linux.c, nat/aarch64-sve-linux-ptrace.c, nat/amd64-linux-siginfo.c, nat/fork-inferior.c, nat/linux-btrace.c, nat/linux-btrace.h, nat/linux-namespaces.c, nat/linux-nat.h, nat/linux-osdata.c, nat/linux-personality.c, nat/linux-procfs.c, nat/linux-ptrace.c, nat/linux-ptrace.h, nat/linux-waitpid.c, nat/mips-linux-watch.c, nat/mips-linux-watch.h, nat/ppc-linux.c, nat/x86-dregs.c, nat/x86-dregs.h, nat/x86-linux-dregs.c, nat/x86-linux.c, nto-procfs.c, nto-tdep.c, objfile-flags.h, objfiles.c, objfiles.h, obsd-nat.c, observable.h, osdata.c, p-valprint.c, parse.c, parser-defs.h, ppc-linux-nat.c, printcmd.c, probe.c, proc-api.c, procfs.c, producer.c, progspace.h, psymtab.h, python/py-framefilter.c, python/py-inferior.c, python/py-ref.h, python/py-type.c, python/python.c, record-btrace.c, record-full.c, record.c, record.h, regcache-dump.c, regcache.c, regcache.h, remote-fileio.c, remote-fileio.h, remote-sim.c, remote.c, riscv-tdep.c, rs6000-aix-tdep.c, rust-exp.y, s12z-tdep.c, selftest-arch.c, ser-base.c, ser-event.c, ser-pipe.c, ser-tcp.c, ser-unix.c, skip.c, solib-aix.c, solib-target.c, solib.c, source-cache.c, source.c, source.h, sparc-nat.c, spu-linux-nat.c, stack.c, stap-probe.c, symfile-add-flags.h, symfile.c, symfile.h, symtab.c, symtab.h, target-descriptions.c, target-descriptions.h, target-memory.c, target.c, target.h, target/waitstatus.c, target/waitstatus.h, thread-iter.h, thread.c, tilegx-tdep.c, top.c, top.h, tracefile-tfile.c, tracefile.c, tracepoint.c, tracepoint.h, tui/tui-io.c, ui-file.c, ui-out.h, unittests/array-view-selftests.c, unittests/child-path-selftests.c, unittests/cli-utils-selftests.c, unittests/common-utils-selftests.c, unittests/copy_bitwise-selftests.c, unittests/environ-selftests.c, unittests/format_pieces-selftests.c, unittests/function-view-selftests.c, unittests/lookup_name_info-selftests.c, unittests/memory-map-selftests.c, unittests/memrange-selftests.c, unittests/mkdir-recursive-selftests.c, unittests/observable-selftests.c, unittests/offset-type-selftests.c, unittests/optional-selftests.c, unittests/parse-connection-spec-selftests.c, unittests/ptid-selftests.c, unittests/rsp-low-selftests.c, unittests/scoped_fd-selftests.c, unittests/scoped_mmap-selftests.c, unittests/scoped_restore-selftests.c, unittests/string_view-selftests.c, unittests/style-selftests.c, unittests/tracepoint-selftests.c, unittests/unpack-selftests.c, unittests/utils-selftests.c, unittests/xml-utils-selftests.c, utils.c, utils.h, valarith.c, valops.c, valprint.c, value.c, value.h, varobj.c, varobj.h, windows-nat.c, x86-linux-nat.c, xml-support.c, xml-support.h, xml-tdesc.h, xstormy16-tdep.c, xtensa-linux-nat.c, dwarf2read.h: Change common to gdbsupport. gdb/gdbserver/ChangeLog 2019-07-09 Tom Tromey <tom@tromey.com> * configure: Rebuild. * configure.ac: Change common to gdbsupport. * acinclude.m4: Change common to gdbsupport. * Makefile.in (SFILES, OBS, GDBREPLAY_OBS, IPA_OBJS) (version-generated.c, gdbsupport/%-ipa.o, gdbsupport/%.o): Change common to gdbsupport. * ax.c, event-loop.c, fork-child.c, gdb_proc_service.h, gdbreplay.c, gdbthread.h, hostio-errno.c, hostio.c, i387-fp.c, inferiors.c, inferiors.h, linux-aarch64-tdesc-selftest.c, linux-amd64-ipa.c, linux-i386-ipa.c, linux-low.c, linux-tic6x-low.c, linux-x86-low.c, linux-x86-tdesc-selftest.c, linux-x86-tdesc.c, lynx-i386-low.c, lynx-low.c, mem-break.h, nto-x86-low.c, regcache.c, regcache.h, remote-utils.c, server.c, server.h, spu-low.c, symbol.c, target.h, tdesc.c, tdesc.h, thread-db.c, tracepoint.c, win32-i386-low.c, win32-low.c: Change common to gdbsupport.
651 lines
16 KiB
C
651 lines
16 KiB
C
/* Memory attributes support, for GDB.
|
||
|
||
Copyright (C) 2001-2019 Free Software Foundation, Inc.
|
||
|
||
This file is part of GDB.
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||
|
||
#include "defs.h"
|
||
#include "command.h"
|
||
#include "gdbcmd.h"
|
||
#include "memattr.h"
|
||
#include "target.h"
|
||
#include "target-dcache.h"
|
||
#include "value.h"
|
||
#include "language.h"
|
||
#include "gdbsupport/vec.h"
|
||
#include "breakpoint.h"
|
||
#include "cli/cli-utils.h"
|
||
#include <algorithm>
|
||
|
||
static std::vector<mem_region> user_mem_region_list, target_mem_region_list;
|
||
static std::vector<mem_region> *mem_region_list = &target_mem_region_list;
|
||
static int mem_number = 0;
|
||
|
||
/* If this flag is set, the memory region list should be automatically
|
||
updated from the target. If it is clear, the list is user-controlled
|
||
and should be left alone. */
|
||
|
||
static bool
|
||
mem_use_target ()
|
||
{
|
||
return mem_region_list == &target_mem_region_list;
|
||
}
|
||
|
||
/* If this flag is set, we have tried to fetch the target memory regions
|
||
since the last time it was invalidated. If that list is still
|
||
empty, then the target can't supply memory regions. */
|
||
static bool target_mem_regions_valid;
|
||
|
||
/* If this flag is set, gdb will assume that memory ranges not
|
||
specified by the memory map have type MEM_NONE, and will
|
||
emit errors on all accesses to that memory. */
|
||
static int inaccessible_by_default = 1;
|
||
|
||
static void
|
||
show_inaccessible_by_default (struct ui_file *file, int from_tty,
|
||
struct cmd_list_element *c,
|
||
const char *value)
|
||
{
|
||
if (inaccessible_by_default)
|
||
fprintf_filtered (file, _("Unknown memory addresses will "
|
||
"be treated as inaccessible.\n"));
|
||
else
|
||
fprintf_filtered (file, _("Unknown memory addresses "
|
||
"will be treated as RAM.\n"));
|
||
}
|
||
|
||
/* This function should be called before any command which would
|
||
modify the memory region list. It will handle switching from
|
||
a target-provided list to a local list, if necessary. */
|
||
|
||
static void
|
||
require_user_regions (int from_tty)
|
||
{
|
||
/* If we're already using a user-provided list, nothing to do. */
|
||
if (!mem_use_target ())
|
||
return;
|
||
|
||
/* Switch to a user-provided list (possibly a copy of the current
|
||
one). */
|
||
mem_region_list = &user_mem_region_list;
|
||
|
||
/* If we don't have a target-provided region list yet, then
|
||
no need to warn. */
|
||
if (target_mem_region_list.empty ())
|
||
return;
|
||
|
||
/* Otherwise, let the user know how to get back. */
|
||
if (from_tty)
|
||
warning (_("Switching to manual control of memory regions; use "
|
||
"\"mem auto\" to fetch regions from the target again."));
|
||
|
||
/* And create a new list (copy of the target-supplied regions) for the user
|
||
to modify. */
|
||
user_mem_region_list = target_mem_region_list;
|
||
}
|
||
|
||
/* This function should be called before any command which would
|
||
read the memory region list, other than those which call
|
||
require_user_regions. It will handle fetching the
|
||
target-provided list, if necessary. */
|
||
|
||
static void
|
||
require_target_regions (void)
|
||
{
|
||
if (mem_use_target () && !target_mem_regions_valid)
|
||
{
|
||
target_mem_regions_valid = true;
|
||
target_mem_region_list = target_memory_map ();
|
||
}
|
||
}
|
||
|
||
/* Create a new user-defined memory region. */
|
||
|
||
static void
|
||
create_user_mem_region (CORE_ADDR lo, CORE_ADDR hi,
|
||
const mem_attrib &attrib)
|
||
{
|
||
/* lo == hi is a useless empty region. */
|
||
if (lo >= hi && hi != 0)
|
||
{
|
||
printf_unfiltered (_("invalid memory region: low >= high\n"));
|
||
return;
|
||
}
|
||
|
||
mem_region newobj (lo, hi, attrib);
|
||
|
||
auto it = std::lower_bound (user_mem_region_list.begin (),
|
||
user_mem_region_list.end (),
|
||
newobj);
|
||
int ix = std::distance (user_mem_region_list.begin (), it);
|
||
|
||
/* Check for an overlapping memory region. We only need to check
|
||
in the vicinity - at most one before and one after the
|
||
insertion point. */
|
||
for (int i = ix - 1; i < ix + 1; i++)
|
||
{
|
||
if (i < 0)
|
||
continue;
|
||
if (i >= user_mem_region_list.size ())
|
||
continue;
|
||
|
||
mem_region &n = user_mem_region_list[i];
|
||
|
||
if ((lo >= n.lo && (lo < n.hi || n.hi == 0))
|
||
|| (hi > n.lo && (hi <= n.hi || n.hi == 0))
|
||
|| (lo <= n.lo && ((hi >= n.hi && n.hi != 0) || hi == 0)))
|
||
{
|
||
printf_unfiltered (_("overlapping memory region\n"));
|
||
return;
|
||
}
|
||
}
|
||
|
||
newobj.number = ++mem_number;
|
||
user_mem_region_list.insert (it, newobj);
|
||
}
|
||
|
||
/* Look up the memory region corresponding to ADDR. */
|
||
|
||
struct mem_region *
|
||
lookup_mem_region (CORE_ADDR addr)
|
||
{
|
||
static struct mem_region region (0, 0);
|
||
CORE_ADDR lo;
|
||
CORE_ADDR hi;
|
||
|
||
require_target_regions ();
|
||
|
||
/* First we initialize LO and HI so that they describe the entire
|
||
memory space. As we process the memory region chain, they are
|
||
redefined to describe the minimal region containing ADDR. LO
|
||
and HI are used in the case where no memory region is defined
|
||
that contains ADDR. If a memory region is disabled, it is
|
||
treated as if it does not exist. The initial values for LO
|
||
and HI represent the bottom and top of memory. */
|
||
|
||
lo = 0;
|
||
hi = 0;
|
||
|
||
/* Either find memory range containing ADDR, or set LO and HI
|
||
to the nearest boundaries of an existing memory range.
|
||
|
||
If we ever want to support a huge list of memory regions, this
|
||
check should be replaced with a binary search (probably using
|
||
VEC_lower_bound). */
|
||
for (mem_region &m : *mem_region_list)
|
||
{
|
||
if (m.enabled_p == 1)
|
||
{
|
||
/* If the address is in the memory region, return that
|
||
memory range. */
|
||
if (addr >= m.lo && (addr < m.hi || m.hi == 0))
|
||
return &m;
|
||
|
||
/* This (correctly) won't match if m->hi == 0, representing
|
||
the top of the address space, because CORE_ADDR is unsigned;
|
||
no value of LO is less than zero. */
|
||
if (addr >= m.hi && lo < m.hi)
|
||
lo = m.hi;
|
||
|
||
/* This will never set HI to zero; if we're here and ADDR
|
||
is at or below M, and the region starts at zero, then ADDR
|
||
would have been in the region. */
|
||
if (addr <= m.lo && (hi == 0 || hi > m.lo))
|
||
hi = m.lo;
|
||
}
|
||
}
|
||
|
||
/* Because no region was found, we must cons up one based on what
|
||
was learned above. */
|
||
region.lo = lo;
|
||
region.hi = hi;
|
||
|
||
/* When no memory map is defined at all, we always return
|
||
'default_mem_attrib', so that we do not make all memory
|
||
inaccessible for targets that don't provide a memory map. */
|
||
if (inaccessible_by_default && !mem_region_list->empty ())
|
||
region.attrib = mem_attrib::unknown ();
|
||
else
|
||
region.attrib = mem_attrib ();
|
||
|
||
return ®ion;
|
||
}
|
||
|
||
/* Invalidate any memory regions fetched from the target. */
|
||
|
||
void
|
||
invalidate_target_mem_regions (void)
|
||
{
|
||
if (!target_mem_regions_valid)
|
||
return;
|
||
|
||
target_mem_regions_valid = false;
|
||
target_mem_region_list.clear ();
|
||
}
|
||
|
||
/* Clear user-defined memory region list. */
|
||
|
||
static void
|
||
user_mem_clear (void)
|
||
{
|
||
user_mem_region_list.clear ();
|
||
}
|
||
|
||
|
||
static void
|
||
mem_command (const char *args, int from_tty)
|
||
{
|
||
CORE_ADDR lo, hi;
|
||
|
||
if (!args)
|
||
error_no_arg (_("No mem"));
|
||
|
||
/* For "mem auto", switch back to using a target provided list. */
|
||
if (strcmp (args, "auto") == 0)
|
||
{
|
||
if (mem_use_target ())
|
||
return;
|
||
|
||
user_mem_clear ();
|
||
mem_region_list = &target_mem_region_list;
|
||
|
||
return;
|
||
}
|
||
|
||
require_user_regions (from_tty);
|
||
|
||
std::string tok = extract_arg (&args);
|
||
if (tok == "")
|
||
error (_("no lo address"));
|
||
lo = parse_and_eval_address (tok.c_str ());
|
||
|
||
tok = extract_arg (&args);
|
||
if (tok == "")
|
||
error (_("no hi address"));
|
||
hi = parse_and_eval_address (tok.c_str ());
|
||
|
||
mem_attrib attrib;
|
||
while ((tok = extract_arg (&args)) != "")
|
||
{
|
||
if (tok == "rw")
|
||
attrib.mode = MEM_RW;
|
||
else if (tok == "ro")
|
||
attrib.mode = MEM_RO;
|
||
else if (tok == "wo")
|
||
attrib.mode = MEM_WO;
|
||
|
||
else if (tok == "8")
|
||
attrib.width = MEM_WIDTH_8;
|
||
else if (tok == "16")
|
||
{
|
||
if ((lo % 2 != 0) || (hi % 2 != 0))
|
||
error (_("region bounds not 16 bit aligned"));
|
||
attrib.width = MEM_WIDTH_16;
|
||
}
|
||
else if (tok == "32")
|
||
{
|
||
if ((lo % 4 != 0) || (hi % 4 != 0))
|
||
error (_("region bounds not 32 bit aligned"));
|
||
attrib.width = MEM_WIDTH_32;
|
||
}
|
||
else if (tok == "64")
|
||
{
|
||
if ((lo % 8 != 0) || (hi % 8 != 0))
|
||
error (_("region bounds not 64 bit aligned"));
|
||
attrib.width = MEM_WIDTH_64;
|
||
}
|
||
|
||
#if 0
|
||
else if (tok == "hwbreak")
|
||
attrib.hwbreak = 1;
|
||
else if (tok == "swbreak")
|
||
attrib.hwbreak = 0;
|
||
#endif
|
||
|
||
else if (tok == "cache")
|
||
attrib.cache = 1;
|
||
else if (tok == "nocache")
|
||
attrib.cache = 0;
|
||
|
||
#if 0
|
||
else if (tok == "verify")
|
||
attrib.verify = 1;
|
||
else if (tok == "noverify")
|
||
attrib.verify = 0;
|
||
#endif
|
||
|
||
else
|
||
error (_("unknown attribute: %s"), tok.c_str ());
|
||
}
|
||
|
||
create_user_mem_region (lo, hi, attrib);
|
||
}
|
||
|
||
|
||
static void
|
||
info_mem_command (const char *args, int from_tty)
|
||
{
|
||
if (mem_use_target ())
|
||
printf_filtered (_("Using memory regions provided by the target.\n"));
|
||
else
|
||
printf_filtered (_("Using user-defined memory regions.\n"));
|
||
|
||
require_target_regions ();
|
||
|
||
if (mem_region_list->empty ())
|
||
{
|
||
printf_unfiltered (_("There are no memory regions defined.\n"));
|
||
return;
|
||
}
|
||
|
||
printf_filtered ("Num ");
|
||
printf_filtered ("Enb ");
|
||
printf_filtered ("Low Addr ");
|
||
if (gdbarch_addr_bit (target_gdbarch ()) > 32)
|
||
printf_filtered (" ");
|
||
printf_filtered ("High Addr ");
|
||
if (gdbarch_addr_bit (target_gdbarch ()) > 32)
|
||
printf_filtered (" ");
|
||
printf_filtered ("Attrs ");
|
||
printf_filtered ("\n");
|
||
|
||
for (const mem_region &m : *mem_region_list)
|
||
{
|
||
const char *tmp;
|
||
|
||
printf_filtered ("%-3d %-3c\t",
|
||
m.number,
|
||
m.enabled_p ? 'y' : 'n');
|
||
if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
|
||
tmp = hex_string_custom (m.lo, 8);
|
||
else
|
||
tmp = hex_string_custom (m.lo, 16);
|
||
|
||
printf_filtered ("%s ", tmp);
|
||
|
||
if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
|
||
{
|
||
if (m.hi == 0)
|
||
tmp = "0x100000000";
|
||
else
|
||
tmp = hex_string_custom (m.hi, 8);
|
||
}
|
||
else
|
||
{
|
||
if (m.hi == 0)
|
||
tmp = "0x10000000000000000";
|
||
else
|
||
tmp = hex_string_custom (m.hi, 16);
|
||
}
|
||
|
||
printf_filtered ("%s ", tmp);
|
||
|
||
/* Print a token for each attribute.
|
||
|
||
* FIXME: Should we output a comma after each token? It may
|
||
* make it easier for users to read, but we'd lose the ability
|
||
* to cut-and-paste the list of attributes when defining a new
|
||
* region. Perhaps that is not important.
|
||
*
|
||
* FIXME: If more attributes are added to GDB, the output may
|
||
* become cluttered and difficult for users to read. At that
|
||
* time, we may want to consider printing tokens only if they
|
||
* are different from the default attribute. */
|
||
|
||
switch (m.attrib.mode)
|
||
{
|
||
case MEM_RW:
|
||
printf_filtered ("rw ");
|
||
break;
|
||
case MEM_RO:
|
||
printf_filtered ("ro ");
|
||
break;
|
||
case MEM_WO:
|
||
printf_filtered ("wo ");
|
||
break;
|
||
case MEM_FLASH:
|
||
printf_filtered ("flash blocksize 0x%x ", m.attrib.blocksize);
|
||
break;
|
||
}
|
||
|
||
switch (m.attrib.width)
|
||
{
|
||
case MEM_WIDTH_8:
|
||
printf_filtered ("8 ");
|
||
break;
|
||
case MEM_WIDTH_16:
|
||
printf_filtered ("16 ");
|
||
break;
|
||
case MEM_WIDTH_32:
|
||
printf_filtered ("32 ");
|
||
break;
|
||
case MEM_WIDTH_64:
|
||
printf_filtered ("64 ");
|
||
break;
|
||
case MEM_WIDTH_UNSPECIFIED:
|
||
break;
|
||
}
|
||
|
||
#if 0
|
||
if (attrib->hwbreak)
|
||
printf_filtered ("hwbreak");
|
||
else
|
||
printf_filtered ("swbreak");
|
||
#endif
|
||
|
||
if (m.attrib.cache)
|
||
printf_filtered ("cache ");
|
||
else
|
||
printf_filtered ("nocache ");
|
||
|
||
#if 0
|
||
if (attrib->verify)
|
||
printf_filtered ("verify ");
|
||
else
|
||
printf_filtered ("noverify ");
|
||
#endif
|
||
|
||
printf_filtered ("\n");
|
||
}
|
||
}
|
||
|
||
|
||
/* Enable the memory region number NUM. */
|
||
|
||
static void
|
||
mem_enable (int num)
|
||
{
|
||
for (mem_region &m : *mem_region_list)
|
||
if (m.number == num)
|
||
{
|
||
m.enabled_p = 1;
|
||
return;
|
||
}
|
||
printf_unfiltered (_("No memory region number %d.\n"), num);
|
||
}
|
||
|
||
static void
|
||
enable_mem_command (const char *args, int from_tty)
|
||
{
|
||
require_user_regions (from_tty);
|
||
|
||
target_dcache_invalidate ();
|
||
|
||
if (args == NULL || *args == '\0')
|
||
{ /* Enable all mem regions. */
|
||
for (mem_region &m : *mem_region_list)
|
||
m.enabled_p = 1;
|
||
}
|
||
else
|
||
{
|
||
number_or_range_parser parser (args);
|
||
while (!parser.finished ())
|
||
{
|
||
int num = parser.get_number ();
|
||
mem_enable (num);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* Disable the memory region number NUM. */
|
||
|
||
static void
|
||
mem_disable (int num)
|
||
{
|
||
for (mem_region &m : *mem_region_list)
|
||
if (m.number == num)
|
||
{
|
||
m.enabled_p = 0;
|
||
return;
|
||
}
|
||
printf_unfiltered (_("No memory region number %d.\n"), num);
|
||
}
|
||
|
||
static void
|
||
disable_mem_command (const char *args, int from_tty)
|
||
{
|
||
require_user_regions (from_tty);
|
||
|
||
target_dcache_invalidate ();
|
||
|
||
if (args == NULL || *args == '\0')
|
||
{
|
||
for (mem_region &m : *mem_region_list)
|
||
m.enabled_p = false;
|
||
}
|
||
else
|
||
{
|
||
number_or_range_parser parser (args);
|
||
while (!parser.finished ())
|
||
{
|
||
int num = parser.get_number ();
|
||
mem_disable (num);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Delete the memory region number NUM. */
|
||
|
||
static void
|
||
mem_delete (int num)
|
||
{
|
||
if (!mem_region_list)
|
||
{
|
||
printf_unfiltered (_("No memory region number %d.\n"), num);
|
||
return;
|
||
}
|
||
|
||
auto it = std::remove_if (mem_region_list->begin (), mem_region_list->end (),
|
||
[num] (const mem_region &m)
|
||
{
|
||
return m.number == num;
|
||
});
|
||
|
||
if (it != mem_region_list->end ())
|
||
mem_region_list->erase (it);
|
||
else
|
||
printf_unfiltered (_("No memory region number %d.\n"), num);
|
||
}
|
||
|
||
static void
|
||
delete_mem_command (const char *args, int from_tty)
|
||
{
|
||
require_user_regions (from_tty);
|
||
|
||
target_dcache_invalidate ();
|
||
|
||
if (args == NULL || *args == '\0')
|
||
{
|
||
if (query (_("Delete all memory regions? ")))
|
||
user_mem_clear ();
|
||
dont_repeat ();
|
||
return;
|
||
}
|
||
|
||
number_or_range_parser parser (args);
|
||
while (!parser.finished ())
|
||
{
|
||
int num = parser.get_number ();
|
||
mem_delete (num);
|
||
}
|
||
|
||
dont_repeat ();
|
||
}
|
||
|
||
static void
|
||
dummy_cmd (const char *args, int from_tty)
|
||
{
|
||
}
|
||
|
||
static struct cmd_list_element *mem_set_cmdlist;
|
||
static struct cmd_list_element *mem_show_cmdlist;
|
||
|
||
void
|
||
_initialize_mem (void)
|
||
{
|
||
add_com ("mem", class_vars, mem_command, _("\
|
||
Define attributes for memory region or reset memory region handling to\n\
|
||
target-based.\n\
|
||
Usage: mem auto\n\
|
||
mem LOW HIGH [MODE WIDTH CACHE],\n\
|
||
where MODE may be rw (read/write), ro (read-only) or wo (write-only),\n\
|
||
WIDTH may be 8, 16, 32, or 64, and\n\
|
||
CACHE may be cache or nocache"));
|
||
|
||
add_cmd ("mem", class_vars, enable_mem_command, _("\
|
||
Enable memory region.\n\
|
||
Arguments are the IDs of the memory regions to enable.\n\
|
||
Usage: enable mem [ID]...\n\
|
||
Do \"info mem\" to see current list of IDs."), &enablelist);
|
||
|
||
add_cmd ("mem", class_vars, disable_mem_command, _("\
|
||
Disable memory region.\n\
|
||
Arguments are the IDs of the memory regions to disable.\n\
|
||
Usage: disable mem [ID]...\n\
|
||
Do \"info mem\" to see current list of IDs."), &disablelist);
|
||
|
||
add_cmd ("mem", class_vars, delete_mem_command, _("\
|
||
Delete memory region.\n\
|
||
Arguments are the IDs of the memory regions to delete.\n\
|
||
Usage: delete mem [ID]...\n\
|
||
Do \"info mem\" to see current list of IDs."), &deletelist);
|
||
|
||
add_info ("mem", info_mem_command,
|
||
_("Memory region attributes"));
|
||
|
||
add_prefix_cmd ("mem", class_vars, dummy_cmd, _("\
|
||
Memory regions settings"),
|
||
&mem_set_cmdlist, "set mem ",
|
||
0/* allow-unknown */, &setlist);
|
||
add_prefix_cmd ("mem", class_vars, dummy_cmd, _("\
|
||
Memory regions settings"),
|
||
&mem_show_cmdlist, "show mem ",
|
||
0/* allow-unknown */, &showlist);
|
||
|
||
add_setshow_boolean_cmd ("inaccessible-by-default", no_class,
|
||
&inaccessible_by_default, _("\
|
||
Set handling of unknown memory regions."), _("\
|
||
Show handling of unknown memory regions."), _("\
|
||
If on, and some memory map is defined, debugger will emit errors on\n\
|
||
accesses to memory not defined in the memory map. If off, accesses to all\n\
|
||
memory addresses will be allowed."),
|
||
NULL,
|
||
show_inaccessible_by_default,
|
||
&mem_set_cmdlist,
|
||
&mem_show_cmdlist);
|
||
}
|