1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include "qemu/osdep.h"
21#include "qemu-common.h"
22#include "cpu.h"
23#include "exec/gdbstub.h"
24#include "qemu/log.h"
25
26enum {
27 xtRegisterTypeArRegfile = 1,
28 xtRegisterTypeSpecialReg,
29 xtRegisterTypeUserReg,
30 xtRegisterTypeTieRegfile,
31 xtRegisterTypeTieState,
32 xtRegisterTypeMapped,
33 xtRegisterTypeUnmapped,
34 xtRegisterTypeWindow,
35 xtRegisterTypeVirtual,
36 xtRegisterTypeUnknown
37};
38
39#define XTENSA_REGISTER_FLAGS_PRIVILEGED 0x0001
40#define XTENSA_REGISTER_FLAGS_READABLE 0x0002
41#define XTENSA_REGISTER_FLAGS_WRITABLE 0x0004
42#define XTENSA_REGISTER_FLAGS_VOLATILE 0x0008
43
44void xtensa_count_regs(const XtensaConfig *config,
45 unsigned *n_regs, unsigned *n_core_regs)
46{
47 unsigned i;
48 bool count_core_regs = true;
49
50 for (i = 0; config->gdb_regmap.reg[i].targno >= 0; ++i) {
51 if (config->gdb_regmap.reg[i].type != xtRegisterTypeTieState &&
52 config->gdb_regmap.reg[i].type != xtRegisterTypeMapped &&
53 config->gdb_regmap.reg[i].type != xtRegisterTypeUnmapped) {
54 ++*n_regs;
55 if (count_core_regs) {
56 if ((config->gdb_regmap.reg[i].flags &
57 XTENSA_REGISTER_FLAGS_PRIVILEGED) == 0) {
58 ++*n_core_regs;
59 } else {
60 count_core_regs = false;
61 }
62 }
63 }
64 }
65}
66
67int xtensa_cpu_gdb_read_register(CPUState *cs, uint8_t *mem_buf, int n)
68{
69 XtensaCPU *cpu = XTENSA_CPU(cs);
70 CPUXtensaState *env = &cpu->env;
71 const XtensaGdbReg *reg = env->config->gdb_regmap.reg + n;
72#ifdef CONFIG_USER_ONLY
73 int num_regs = env->config->gdb_regmap.num_core_regs;
74#else
75 int num_regs = env->config->gdb_regmap.num_regs;
76#endif
77 unsigned i;
78
79 if (n < 0 || n >= num_regs) {
80 return 0;
81 }
82
83 switch (reg->type) {
84 case xtRegisterTypeVirtual:
85 return gdb_get_reg32(mem_buf, env->pc);
86
87 case xtRegisterTypeArRegfile:
88 xtensa_sync_phys_from_window(env);
89 return gdb_get_reg32(mem_buf, env->phys_regs[(reg->targno & 0xff)
90 % env->config->nareg]);
91
92 case xtRegisterTypeSpecialReg:
93 return gdb_get_reg32(mem_buf, env->sregs[reg->targno & 0xff]);
94
95 case xtRegisterTypeUserReg:
96 return gdb_get_reg32(mem_buf, env->uregs[reg->targno & 0xff]);
97
98 case xtRegisterTypeTieRegfile:
99 i = reg->targno & 0x0f;
100 switch (reg->size) {
101 case 4:
102 return gdb_get_reg32(mem_buf,
103 float32_val(env->fregs[i].f32[FP_F32_LOW]));
104 case 8:
105 return gdb_get_reg64(mem_buf, float64_val(env->fregs[i].f64));
106 default:
107 qemu_log_mask(LOG_UNIMP, "%s from reg %d of unsupported size %d\n",
108 __func__, n, reg->size);
109 memset(mem_buf, 0, reg->size);
110 return reg->size;
111 }
112
113 case xtRegisterTypeWindow:
114 return gdb_get_reg32(mem_buf, env->regs[reg->targno & 0x0f]);
115
116 default:
117 qemu_log_mask(LOG_UNIMP, "%s from reg %d of unsupported type %d\n",
118 __func__, n, reg->type);
119 memset(mem_buf, 0, reg->size);
120 return reg->size;
121 }
122}
123
124int xtensa_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
125{
126 XtensaCPU *cpu = XTENSA_CPU(cs);
127 CPUXtensaState *env = &cpu->env;
128 uint32_t tmp;
129 const XtensaGdbReg *reg = env->config->gdb_regmap.reg + n;
130#ifdef CONFIG_USER_ONLY
131 int num_regs = env->config->gdb_regmap.num_core_regs;
132#else
133 int num_regs = env->config->gdb_regmap.num_regs;
134#endif
135
136 if (n < 0 || n >= num_regs) {
137 return 0;
138 }
139
140 tmp = ldl_p(mem_buf);
141
142 switch (reg->type) {
143 case xtRegisterTypeVirtual:
144 env->pc = tmp;
145 break;
146
147 case xtRegisterTypeArRegfile:
148 env->phys_regs[(reg->targno & 0xff) % env->config->nareg] = tmp;
149 xtensa_sync_window_from_phys(env);
150 break;
151
152 case xtRegisterTypeSpecialReg:
153 env->sregs[reg->targno & 0xff] = tmp;
154 break;
155
156 case xtRegisterTypeUserReg:
157 env->uregs[reg->targno & 0xff] = tmp;
158 break;
159
160 case xtRegisterTypeTieRegfile:
161 switch (reg->size) {
162 case 4:
163 env->fregs[reg->targno & 0x0f].f32[FP_F32_LOW] = make_float32(tmp);
164 return 4;
165 case 8:
166 env->fregs[reg->targno & 0x0f].f64 = make_float64(tmp);
167 return 8;
168 default:
169 qemu_log_mask(LOG_UNIMP, "%s to reg %d of unsupported size %d\n",
170 __func__, n, reg->size);
171 return reg->size;
172 }
173
174 case xtRegisterTypeWindow:
175 env->regs[reg->targno & 0x0f] = tmp;
176 break;
177
178 default:
179 qemu_log_mask(LOG_UNIMP, "%s to reg %d of unsupported type %d\n",
180 __func__, n, reg->type);
181 return reg->size;
182 }
183
184 return 4;
185}
186