f214bdde5a
Create a subroutine for creating the union of unions of the various type sizes that a vector may contain. Reviewed-by: Fabiano Rosas <farosas@suse.de> Reviewed-by: Peter Maydell <peter.maydell@linaro.org> Signed-off-by: Richard Henderson <richard.henderson@linaro.org> Message-id: 20230227213329.793795-5-richard.henderson@linaro.org Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
337 lines
10 KiB
C
337 lines
10 KiB
C
/*
|
|
* ARM gdb server stub: AArch64 specific functions.
|
|
*
|
|
* Copyright (c) 2013 SUSE LINUX Products GmbH
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include "qemu/osdep.h"
|
|
#include "qemu/log.h"
|
|
#include "cpu.h"
|
|
#include "internals.h"
|
|
#include "exec/gdbstub.h"
|
|
|
|
int aarch64_cpu_gdb_read_register(CPUState *cs, GByteArray *mem_buf, int n)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
CPUARMState *env = &cpu->env;
|
|
|
|
if (n < 31) {
|
|
/* Core integer register. */
|
|
return gdb_get_reg64(mem_buf, env->xregs[n]);
|
|
}
|
|
switch (n) {
|
|
case 31:
|
|
return gdb_get_reg64(mem_buf, env->xregs[31]);
|
|
case 32:
|
|
return gdb_get_reg64(mem_buf, env->pc);
|
|
case 33:
|
|
return gdb_get_reg32(mem_buf, pstate_read(env));
|
|
}
|
|
/* Unknown register. */
|
|
return 0;
|
|
}
|
|
|
|
int aarch64_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
CPUARMState *env = &cpu->env;
|
|
uint64_t tmp;
|
|
|
|
tmp = ldq_p(mem_buf);
|
|
|
|
if (n < 31) {
|
|
/* Core integer register. */
|
|
env->xregs[n] = tmp;
|
|
return 8;
|
|
}
|
|
switch (n) {
|
|
case 31:
|
|
env->xregs[31] = tmp;
|
|
return 8;
|
|
case 32:
|
|
env->pc = tmp;
|
|
return 8;
|
|
case 33:
|
|
/* CPSR */
|
|
pstate_write(env, tmp);
|
|
return 4;
|
|
}
|
|
/* Unknown register. */
|
|
return 0;
|
|
}
|
|
|
|
int aarch64_gdb_get_fpu_reg(CPUARMState *env, GByteArray *buf, int reg)
|
|
{
|
|
switch (reg) {
|
|
case 0 ... 31:
|
|
{
|
|
/* 128 bit FP register - quads are in LE order */
|
|
uint64_t *q = aa64_vfp_qreg(env, reg);
|
|
return gdb_get_reg128(buf, q[1], q[0]);
|
|
}
|
|
case 32:
|
|
/* FPSR */
|
|
return gdb_get_reg32(buf, vfp_get_fpsr(env));
|
|
case 33:
|
|
/* FPCR */
|
|
return gdb_get_reg32(buf, vfp_get_fpcr(env));
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int aarch64_gdb_set_fpu_reg(CPUARMState *env, uint8_t *buf, int reg)
|
|
{
|
|
switch (reg) {
|
|
case 0 ... 31:
|
|
/* 128 bit FP register */
|
|
{
|
|
uint64_t *q = aa64_vfp_qreg(env, reg);
|
|
q[0] = ldq_le_p(buf);
|
|
q[1] = ldq_le_p(buf + 8);
|
|
return 16;
|
|
}
|
|
case 32:
|
|
/* FPSR */
|
|
vfp_set_fpsr(env, ldl_p(buf));
|
|
return 4;
|
|
case 33:
|
|
/* FPCR */
|
|
vfp_set_fpcr(env, ldl_p(buf));
|
|
return 4;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int aarch64_gdb_get_sve_reg(CPUARMState *env, GByteArray *buf, int reg)
|
|
{
|
|
ARMCPU *cpu = env_archcpu(env);
|
|
|
|
switch (reg) {
|
|
/* The first 32 registers are the zregs */
|
|
case 0 ... 31:
|
|
{
|
|
int vq, len = 0;
|
|
for (vq = 0; vq < cpu->sve_max_vq; vq++) {
|
|
len += gdb_get_reg128(buf,
|
|
env->vfp.zregs[reg].d[vq * 2 + 1],
|
|
env->vfp.zregs[reg].d[vq * 2]);
|
|
}
|
|
return len;
|
|
}
|
|
case 32:
|
|
return gdb_get_reg32(buf, vfp_get_fpsr(env));
|
|
case 33:
|
|
return gdb_get_reg32(buf, vfp_get_fpcr(env));
|
|
/* then 16 predicates and the ffr */
|
|
case 34 ... 50:
|
|
{
|
|
int preg = reg - 34;
|
|
int vq, len = 0;
|
|
for (vq = 0; vq < cpu->sve_max_vq; vq = vq + 4) {
|
|
len += gdb_get_reg64(buf, env->vfp.pregs[preg].p[vq / 4]);
|
|
}
|
|
return len;
|
|
}
|
|
case 51:
|
|
{
|
|
/*
|
|
* We report in Vector Granules (VG) which is 64bit in a Z reg
|
|
* while the ZCR works in Vector Quads (VQ) which is 128bit chunks.
|
|
*/
|
|
int vq = sve_vqm1_for_el(env, arm_current_el(env)) + 1;
|
|
return gdb_get_reg64(buf, vq * 2);
|
|
}
|
|
default:
|
|
/* gdbstub asked for something out our range */
|
|
qemu_log_mask(LOG_UNIMP, "%s: out of range register %d", __func__, reg);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int aarch64_gdb_set_sve_reg(CPUARMState *env, uint8_t *buf, int reg)
|
|
{
|
|
ARMCPU *cpu = env_archcpu(env);
|
|
|
|
/* The first 32 registers are the zregs */
|
|
switch (reg) {
|
|
/* The first 32 registers are the zregs */
|
|
case 0 ... 31:
|
|
{
|
|
int vq, len = 0;
|
|
uint64_t *p = (uint64_t *) buf;
|
|
for (vq = 0; vq < cpu->sve_max_vq; vq++) {
|
|
env->vfp.zregs[reg].d[vq * 2 + 1] = *p++;
|
|
env->vfp.zregs[reg].d[vq * 2] = *p++;
|
|
len += 16;
|
|
}
|
|
return len;
|
|
}
|
|
case 32:
|
|
vfp_set_fpsr(env, *(uint32_t *)buf);
|
|
return 4;
|
|
case 33:
|
|
vfp_set_fpcr(env, *(uint32_t *)buf);
|
|
return 4;
|
|
case 34 ... 50:
|
|
{
|
|
int preg = reg - 34;
|
|
int vq, len = 0;
|
|
uint64_t *p = (uint64_t *) buf;
|
|
for (vq = 0; vq < cpu->sve_max_vq; vq = vq + 4) {
|
|
env->vfp.pregs[preg].p[vq / 4] = *p++;
|
|
len += 8;
|
|
}
|
|
return len;
|
|
}
|
|
case 51:
|
|
/* cannot set vg via gdbstub */
|
|
return 0;
|
|
default:
|
|
/* gdbstub asked for something out our range */
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void output_vector_union_type(GString *s, int reg_width)
|
|
{
|
|
struct TypeSize {
|
|
const char *gdb_type;
|
|
short size;
|
|
char sz, suffix;
|
|
};
|
|
|
|
static const struct TypeSize vec_lanes[] = {
|
|
/* quads */
|
|
{ "uint128", 128, 'q', 'u' },
|
|
{ "int128", 128, 'q', 's' },
|
|
/* 64 bit */
|
|
{ "ieee_double", 64, 'd', 'f' },
|
|
{ "uint64", 64, 'd', 'u' },
|
|
{ "int64", 64, 'd', 's' },
|
|
/* 32 bit */
|
|
{ "ieee_single", 32, 's', 'f' },
|
|
{ "uint32", 32, 's', 'u' },
|
|
{ "int32", 32, 's', 's' },
|
|
/* 16 bit */
|
|
{ "ieee_half", 16, 'h', 'f' },
|
|
{ "uint16", 16, 'h', 'u' },
|
|
{ "int16", 16, 'h', 's' },
|
|
/* bytes */
|
|
{ "uint8", 8, 'b', 'u' },
|
|
{ "int8", 8, 'b', 's' },
|
|
};
|
|
|
|
static const char suf[] = { 'q', 'd', 's', 'h', 'b' };
|
|
|
|
g_autoptr(GString) ts = g_string_new("");
|
|
int i, j, bits;
|
|
|
|
/* First define types and totals in a whole VL */
|
|
for (i = 0; i < ARRAY_SIZE(vec_lanes); i++) {
|
|
int count = reg_width / vec_lanes[i].size;
|
|
g_string_printf(ts, "svev%c%c", vec_lanes[i].sz, vec_lanes[i].suffix);
|
|
g_string_append_printf(s,
|
|
"<vector id=\"%s\" type=\"%s\" count=\"%d\"/>",
|
|
ts->str, vec_lanes[i].gdb_type, count);
|
|
}
|
|
/*
|
|
* Now define a union for each size group containing unsigned and
|
|
* signed and potentially float versions of each size from 128 to
|
|
* 8 bits.
|
|
*/
|
|
for (bits = 128, i = 0; bits >= 8; bits /= 2, i++) {
|
|
g_string_append_printf(s, "<union id=\"svevn%c\">", suf[i]);
|
|
for (j = 0; j < ARRAY_SIZE(vec_lanes); j++) {
|
|
if (vec_lanes[j].size == bits) {
|
|
g_string_append_printf(s, "<field name=\"%c\" type=\"svev%c%c\"/>",
|
|
vec_lanes[j].suffix,
|
|
vec_lanes[j].sz, vec_lanes[j].suffix);
|
|
}
|
|
}
|
|
g_string_append(s, "</union>");
|
|
}
|
|
/* And now the final union of unions */
|
|
g_string_append(s, "<union id=\"svev\">");
|
|
for (bits = 128, i = 0; bits >= 8; bits /= 2, i++) {
|
|
g_string_append_printf(s, "<field name=\"%c\" type=\"svevn%c\"/>",
|
|
suf[i], suf[i]);
|
|
}
|
|
g_string_append(s, "</union>");
|
|
}
|
|
|
|
int arm_gen_dynamic_svereg_xml(CPUState *cs, int base_reg)
|
|
{
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
GString *s = g_string_new(NULL);
|
|
DynamicGDBXMLInfo *info = &cpu->dyn_svereg_xml;
|
|
int i, reg_width = (cpu->sve_max_vq * 128);
|
|
info->num = 0;
|
|
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.aarch64.sve\">");
|
|
|
|
output_vector_union_type(s, reg_width);
|
|
|
|
/* Finally the sve prefix type */
|
|
g_string_append_printf(s,
|
|
"<vector id=\"svep\" type=\"uint8\" count=\"%d\"/>",
|
|
reg_width / 8);
|
|
|
|
/* Then define each register in parts for each vq */
|
|
for (i = 0; i < 32; i++) {
|
|
g_string_append_printf(s,
|
|
"<reg name=\"z%d\" bitsize=\"%d\""
|
|
" regnum=\"%d\" type=\"svev\"/>",
|
|
i, reg_width, base_reg++);
|
|
info->num++;
|
|
}
|
|
/* fpscr & status registers */
|
|
g_string_append_printf(s, "<reg name=\"fpsr\" bitsize=\"32\""
|
|
" regnum=\"%d\" group=\"float\""
|
|
" type=\"int\"/>", base_reg++);
|
|
g_string_append_printf(s, "<reg name=\"fpcr\" bitsize=\"32\""
|
|
" regnum=\"%d\" group=\"float\""
|
|
" type=\"int\"/>", base_reg++);
|
|
info->num += 2;
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
g_string_append_printf(s,
|
|
"<reg name=\"p%d\" bitsize=\"%d\""
|
|
" regnum=\"%d\" type=\"svep\"/>",
|
|
i, cpu->sve_max_vq * 16, base_reg++);
|
|
info->num++;
|
|
}
|
|
g_string_append_printf(s,
|
|
"<reg name=\"ffr\" bitsize=\"%d\""
|
|
" regnum=\"%d\" group=\"vector\""
|
|
" type=\"svep\"/>",
|
|
cpu->sve_max_vq * 16, base_reg++);
|
|
g_string_append_printf(s,
|
|
"<reg name=\"vg\" bitsize=\"64\""
|
|
" regnum=\"%d\" type=\"int\"/>",
|
|
base_reg++);
|
|
info->num += 2;
|
|
g_string_append_printf(s, "</feature>");
|
|
info->desc = g_string_free(s, false);
|
|
|
|
return info->num;
|
|
}
|