From: Richard Henderson <richard.henderson@linaro.org>
To: qemu-devel@nongnu.org
Cc: qemu-arm@nongnu.org, David Reiss <dreiss@meta.com>
Subject: [PATCH 14/14] target/arm: Support reading m-profile system registers from gdb
Date: Tue, 14 Feb 2023 06:30:48 -1000 [thread overview]
Message-ID: <20230214163048.903964-15-richard.henderson@linaro.org> (raw)
In-Reply-To: <20230214163048.903964-1-richard.henderson@linaro.org>
From: David Reiss <dreiss@meta.com>
Follows a fairly similar pattern to the existing special register
debug support. Only reading is implemented, but it should be
possible to implement writes.
Signed-off-by: David Reiss <dreiss@meta.com>
[rth: Split out from two other patches;
Use an enumeration to locally number the registers.
Use a structure to list and control runtime visibility.
Handle security extension with the same code.]
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
target/arm/cpu.h | 1 +
target/arm/gdbstub.c | 169 +++++++++++++++++++++++++++++++++++++++++++
2 files changed, 170 insertions(+)
diff --git a/target/arm/cpu.h b/target/arm/cpu.h
index c9f768f945..536e60d48c 100644
--- a/target/arm/cpu.h
+++ b/target/arm/cpu.h
@@ -867,6 +867,7 @@ struct ArchCPU {
DynamicGDBXMLInfo dyn_sysreg_xml;
DynamicGDBXMLInfo dyn_svereg_xml;
+ DynamicGDBXMLInfo dyn_m_systemreg_xml;
/* Timers used by the generic (architected) timer */
QEMUTimer *gt_timer[NUM_GTIMERS];
diff --git a/target/arm/gdbstub.c b/target/arm/gdbstub.c
index 062c8d447a..a8848c7fee 100644
--- a/target/arm/gdbstub.c
+++ b/target/arm/gdbstub.c
@@ -322,6 +322,167 @@ static int arm_gen_dynamic_sysreg_xml(CPUState *cs, int base_reg)
return cpu->dyn_sysreg_xml.num;
}
+enum {
+ M_SYSREG_MSP = 0,
+ M_SYSREG_PSP = 1,
+ M_SYSREG_PRIMASK = 2,
+ M_SYSREG_CONTROL = 3,
+ M_SYSREG_BASEPRI = 4,
+ M_SYSREG_FAULTMASK = 5,
+ M_SYSREG_MSPLIM = 6,
+ M_SYSREG_PSPLIM = 7,
+ M_SYSREG_REG_MASK = 7,
+
+ /*
+ * NOTE: MSP, PSP, MSPLIM, PSPLIM technically don't exist if the
+ * secure extension is present (replaced by MSP_S, MSP_NS, et al).
+ * However, the MRS instruction is still allowed to read from MSP and PSP,
+ * and will return the value associated with the current security state.
+ * We replicate this behavior for the convenience of users, who will see
+ * GDB behave similarly to their assembly code, even if they are oblivious
+ * to the security extension.
+ */
+ M_SYSREG_CURRENT = 0 << 3,
+ M_SYSREG_NONSECURE = 1 << 3,
+ M_SYSREG_SECURE = 2 << 3,
+ M_SYSREG_MODE_MASK = 3 << 3,
+};
+
+static const struct {
+ const char *name;
+ int feature;
+} m_systemreg_def[] = {
+ [M_SYSREG_MSP] = { "msp", ARM_FEATURE_M },
+ [M_SYSREG_PSP] = { "psp", ARM_FEATURE_M },
+ [M_SYSREG_PRIMASK] = { "primask", ARM_FEATURE_M },
+ [M_SYSREG_CONTROL] = { "control", ARM_FEATURE_M },
+ [M_SYSREG_BASEPRI] = { "basepri", ARM_FEATURE_M_MAIN },
+ [M_SYSREG_FAULTMASK] = { "faultmask", ARM_FEATURE_M_MAIN },
+ [M_SYSREG_MSPLIM] = { "msplim", ARM_FEATURE_V8 },
+ [M_SYSREG_PSPLIM] = { "psplim", ARM_FEATURE_V8 },
+};
+
+static int arm_gdb_get_m_systemreg(CPUARMState *env, GByteArray *buf, int reg)
+{
+ int mode = reg & M_SYSREG_MODE_MASK;
+ bool secure;
+ uint32_t val;
+
+ switch (mode) {
+ case M_SYSREG_CURRENT:
+ secure = env->v7m.secure;
+ break;
+ case M_SYSREG_NONSECURE:
+ secure = false;
+ break;
+ case M_SYSREG_SECURE:
+ secure = true;
+ break;
+ default:
+ return 0;
+ }
+
+ reg &= M_SYSREG_REG_MASK;
+ if (reg >= ARRAY_SIZE(m_systemreg_def)) {
+ return 0;
+ }
+ if (!arm_feature(env, m_systemreg_def[reg].feature)) {
+ return 0;
+ }
+
+ /* NOTE: This implementation shares a lot of logic with v7m_mrs. */
+ switch (reg) {
+ case M_SYSREG_MSP:
+ val = *arm_v7m_get_sp_ptr(env, secure, false, true);
+ break;
+ case M_SYSREG_PSP:
+ val = *arm_v7m_get_sp_ptr(env, secure, true, true);
+ break;
+ case M_SYSREG_MSPLIM:
+ val = env->v7m.msplim[secure];
+ break;
+ case M_SYSREG_PSPLIM:
+ val = env->v7m.psplim[secure];
+ break;
+ case M_SYSREG_PRIMASK:
+ val = env->v7m.primask[secure];
+ break;
+ case M_SYSREG_BASEPRI:
+ val = env->v7m.basepri[secure];
+ break;
+ case M_SYSREG_FAULTMASK:
+ val = env->v7m.faultmask[secure];
+ break;
+ case M_SYSREG_CONTROL:
+ /*
+ * NOTE: CONTROL has a mix of banked and non-banked bits.
+ * For "current", we emulate the MRS instruction.
+ * Unfortunately, this gives GDB no way to read the SFPA bit
+ * when the CPU is in a non-secure state.
+ */
+ if (mode == M_SYSREG_CURRENT) {
+ val = arm_v7m_mrs_control(env, secure);
+ } else {
+ val = env->v7m.control[secure];
+ }
+ break;
+ default:
+ g_assert_not_reached();
+ }
+
+ return gdb_get_reg32(buf, val);
+}
+
+static int arm_gdb_set_m_systemreg(CPUARMState *env, uint8_t *buf, int reg)
+{
+ /* TODO: Implement. */
+ return 0;
+}
+
+static int arm_gen_dynamic_m_systemreg_xml(CPUState *cs, int base_reg)
+{
+ ARMCPU *cpu = ARM_CPU(cs);
+ CPUARMState *env = &cpu->env;
+ GString *s = g_string_new(NULL);
+ int i, ret;
+
+ g_string_printf(s, "<?xml version=\"1.0\"?>");
+ g_string_append_printf(s, "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">");
+ g_string_append_printf(s, "<feature name=\"org.gnu.gdb.arm.m-system\">\n");
+
+ QEMU_BUILD_BUG_ON(M_SYSREG_CURRENT != 0);
+ ret = ARRAY_SIZE(m_systemreg_def);
+
+ for (i = 0; i < ret; i++) {
+ if (arm_feature(env, m_systemreg_def[i].feature)) {
+ g_string_append_printf(s,
+ "<reg name=\"%s\" bitsize=\"32\" regnum=\"%d\"/>\n",
+ m_systemreg_def[i].name, base_reg + i);
+ }
+ }
+
+ if (arm_feature(env, ARM_FEATURE_M_SECURITY)) {
+ for (i = 0; i < ret; i++) {
+ g_string_append_printf(s,
+ "<reg name=\"%s_ns\" bitsize=\"32\" regnum=\"%d\"/>\n",
+ m_systemreg_def[i].name, base_reg + (i | M_SYSREG_NONSECURE));
+ }
+ for (i = 0; i < ret; i++) {
+ g_string_append_printf(s,
+ "<reg name=\"%s_s\" bitsize=\"32\" regnum=\"%d\"/>\n",
+ m_systemreg_def[i].name, base_reg + (i | M_SYSREG_SECURE));
+ }
+ QEMU_BUILD_BUG_ON(M_SYSREG_SECURE < M_SYSREG_NONSECURE);
+ ret |= M_SYSREG_SECURE;
+ }
+
+ g_string_append_printf(s, "</feature>");
+
+ cpu->dyn_m_systemreg_xml.desc = g_string_free(s, false);
+ cpu->dyn_m_systemreg_xml.num = ret;
+ return ret;
+}
+
const char *arm_gdb_get_dynamic_xml(CPUState *cs, const char *xmlname)
{
ARMCPU *cpu = ARM_CPU(cs);
@@ -330,6 +491,8 @@ const char *arm_gdb_get_dynamic_xml(CPUState *cs, const char *xmlname)
return cpu->dyn_sysreg_xml.desc;
} else if (strcmp(xmlname, "sve-registers.xml") == 0) {
return cpu->dyn_svereg_xml.desc;
+ } else if (strcmp(xmlname, "arm-m-system.xml") == 0) {
+ return cpu->dyn_m_systemreg_xml.desc;
}
return NULL;
}
@@ -389,4 +552,10 @@ void arm_cpu_register_gdb_regs_for_features(ARMCPU *cpu)
arm_gen_dynamic_sysreg_xml(cs, cs->gdb_num_regs),
"system-registers.xml", 0);
+ if (arm_feature(env, ARM_FEATURE_M)) {
+ gdb_register_coprocessor(cs,
+ arm_gdb_get_m_systemreg, arm_gdb_set_m_systemreg,
+ arm_gen_dynamic_m_systemreg_xml(cs, cs->gdb_num_regs),
+ "arm-m-system.xml", 0);
+ }
}
--
2.34.1
next prev parent reply other threads:[~2023-02-14 16:31 UTC|newest]
Thread overview: 35+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-02-14 16:30 [PATCH 00/14] target/arm: gdbstub cleanups and additions Richard Henderson
2023-02-14 16:30 ` [PATCH 01/14] target/arm: Normalize aarch64 gdbstub get/set function names Richard Henderson
2023-02-14 18:55 ` Fabiano Rosas
2023-02-14 16:30 ` [PATCH 02/14] target/arm: Unexport arm_gen_dynamic_sysreg_xml Richard Henderson
2023-02-14 18:57 ` Fabiano Rosas
2023-02-14 16:30 ` [PATCH 03/14] target/arm: Move arm_gen_dynamic_svereg_xml to gdbstub64.c Richard Henderson
2023-02-14 19:08 ` Fabiano Rosas
2023-02-14 16:30 ` [PATCH 04/14] target/arm: Split out output_vector_union_type Richard Henderson
2023-02-14 19:35 ` Fabiano Rosas
2023-02-20 16:07 ` Peter Maydell
2023-02-14 16:30 ` [PATCH 05/14] target/arm: Simplify register counting in arm_gen_dynamic_svereg_xml Richard Henderson
2023-02-14 19:42 ` Fabiano Rosas
2023-02-14 22:56 ` Richard Henderson
2023-02-14 16:30 ` [PATCH 06/14] target/arm: Hoist pred_width " Richard Henderson
2023-02-14 19:44 ` Fabiano Rosas
2023-02-14 16:30 ` [PATCH 07/14] target/arm: Fix svep width " Richard Henderson
2023-02-20 16:18 ` Peter Maydell
2023-02-14 16:30 ` [PATCH 08/14] target/arm: Add name argument to output_vector_union_type Richard Henderson
2023-02-20 16:20 ` Peter Maydell
2023-02-14 16:30 ` [PATCH 09/14] target/arm: Simplify iteration over bit widths Richard Henderson
2023-02-20 16:24 ` Peter Maydell
2023-02-14 16:30 ` [PATCH 10/14] target/arm: Create pauth_ptr_mask Richard Henderson
2023-02-20 16:39 ` Peter Maydell
2023-02-14 16:30 ` [PATCH 11/14] target/arm: Implement gdbstub pauth extension Richard Henderson
2023-02-20 16:58 ` Peter Maydell
2023-02-14 16:30 ` [PATCH 12/14] target/arm: Export arm_v7m_mrs_control Richard Henderson
2023-02-20 16:50 ` Peter Maydell
2023-02-14 16:30 ` [PATCH 13/14] target/arm: Export arm_v7m_get_sp_ptr Richard Henderson
2023-02-20 16:51 ` Peter Maydell
2023-02-14 16:30 ` Richard Henderson [this message]
2023-02-14 16:33 ` [PATCH 14/14] target/arm: Support reading m-profile system registers from gdb Richard Henderson
2023-02-20 16:02 ` Peter Maydell
2023-02-20 17:00 ` Richard Henderson
2023-02-20 17:37 ` Peter Maydell
2023-02-20 18:27 ` Luis Machado
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20230214163048.903964-15-richard.henderson@linaro.org \
--to=richard.henderson@linaro.org \
--cc=dreiss@meta.com \
--cc=qemu-arm@nongnu.org \
--cc=qemu-devel@nongnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).