]>
Commit | Line | Data |
---|---|---|
2c0262af FB |
1 | /* |
2 | * ARM virtual CPU header | |
5fafdf24 | 3 | * |
2c0262af FB |
4 | * Copyright (c) 2003 Fabrice Bellard |
5 | * | |
6 | * This library is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU Lesser General Public | |
8 | * License as published by the Free Software Foundation; either | |
9 | * version 2 of the License, or (at your option) any later version. | |
10 | * | |
11 | * This library is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | * Lesser General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU Lesser General Public | |
8167ee88 | 17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
2c0262af FB |
18 | */ |
19 | #ifndef CPU_ARM_H | |
20 | #define CPU_ARM_H | |
21 | ||
3926cc84 | 22 | #include "config.h" |
3cf1e035 | 23 | |
72b0cd35 PM |
24 | #include "kvm-consts.h" |
25 | ||
3926cc84 AG |
26 | #if defined(TARGET_AARCH64) |
27 | /* AArch64 definitions */ | |
28 | # define TARGET_LONG_BITS 64 | |
29 | # define ELF_MACHINE EM_AARCH64 | |
30 | #else | |
31 | # define TARGET_LONG_BITS 32 | |
32 | # define ELF_MACHINE EM_ARM | |
33 | #endif | |
9042c0e2 | 34 | |
84f2bed3 PS |
35 | #define TARGET_IS_BIENDIAN 1 |
36 | ||
9349b4f9 | 37 | #define CPUArchState struct CPUARMState |
c2764719 | 38 | |
9a78eead | 39 | #include "qemu-common.h" |
022c62cb | 40 | #include "exec/cpu-defs.h" |
2c0262af | 41 | |
6b4c305c | 42 | #include "fpu/softfloat.h" |
53cd6637 | 43 | |
b8a9e8f1 FB |
44 | #define EXCP_UDEF 1 /* undefined instruction */ |
45 | #define EXCP_SWI 2 /* software interrupt */ | |
46 | #define EXCP_PREFETCH_ABORT 3 | |
47 | #define EXCP_DATA_ABORT 4 | |
b5ff1b31 FB |
48 | #define EXCP_IRQ 5 |
49 | #define EXCP_FIQ 6 | |
06c949e6 | 50 | #define EXCP_BKPT 7 |
9ee6e8bb | 51 | #define EXCP_EXCEPTION_EXIT 8 /* Return from v7M exception. */ |
fbb4a2e3 | 52 | #define EXCP_KERNEL_TRAP 9 /* Jumped to kernel code page. */ |
426f5abc | 53 | #define EXCP_STREX 10 |
35979d71 | 54 | #define EXCP_HVC 11 /* HyperVisor Call */ |
607d98b8 | 55 | #define EXCP_HYP_TRAP 12 |
e0d6e6a5 | 56 | #define EXCP_SMC 13 /* Secure Monitor Call */ |
136e67e9 EI |
57 | #define EXCP_VIRQ 14 |
58 | #define EXCP_VFIQ 15 | |
9ee6e8bb PB |
59 | |
60 | #define ARMV7M_EXCP_RESET 1 | |
61 | #define ARMV7M_EXCP_NMI 2 | |
62 | #define ARMV7M_EXCP_HARD 3 | |
63 | #define ARMV7M_EXCP_MEM 4 | |
64 | #define ARMV7M_EXCP_BUS 5 | |
65 | #define ARMV7M_EXCP_USAGE 6 | |
66 | #define ARMV7M_EXCP_SVC 11 | |
67 | #define ARMV7M_EXCP_DEBUG 12 | |
68 | #define ARMV7M_EXCP_PENDSV 14 | |
69 | #define ARMV7M_EXCP_SYSTICK 15 | |
2c0262af | 70 | |
403946c0 RH |
71 | /* ARM-specific interrupt pending bits. */ |
72 | #define CPU_INTERRUPT_FIQ CPU_INTERRUPT_TGT_EXT_1 | |
136e67e9 EI |
73 | #define CPU_INTERRUPT_VIRQ CPU_INTERRUPT_TGT_EXT_2 |
74 | #define CPU_INTERRUPT_VFIQ CPU_INTERRUPT_TGT_EXT_3 | |
403946c0 | 75 | |
e4fe830b PM |
76 | /* The usual mapping for an AArch64 system register to its AArch32 |
77 | * counterpart is for the 32 bit world to have access to the lower | |
78 | * half only (with writes leaving the upper half untouched). It's | |
79 | * therefore useful to be able to pass TCG the offset of the least | |
80 | * significant half of a uint64_t struct member. | |
81 | */ | |
82 | #ifdef HOST_WORDS_BIGENDIAN | |
5cd8a118 | 83 | #define offsetoflow32(S, M) (offsetof(S, M) + sizeof(uint32_t)) |
b0fe2427 | 84 | #define offsetofhigh32(S, M) offsetof(S, M) |
e4fe830b PM |
85 | #else |
86 | #define offsetoflow32(S, M) offsetof(S, M) | |
b0fe2427 | 87 | #define offsetofhigh32(S, M) (offsetof(S, M) + sizeof(uint32_t)) |
e4fe830b PM |
88 | #endif |
89 | ||
136e67e9 | 90 | /* Meanings of the ARMCPU object's four inbound GPIO lines */ |
7c1840b6 PM |
91 | #define ARM_CPU_IRQ 0 |
92 | #define ARM_CPU_FIQ 1 | |
136e67e9 EI |
93 | #define ARM_CPU_VIRQ 2 |
94 | #define ARM_CPU_VFIQ 3 | |
403946c0 | 95 | |
c1713132 AZ |
96 | typedef void ARMWriteCPFunc(void *opaque, int cp_info, |
97 | int srcreg, int operand, uint32_t value); | |
98 | typedef uint32_t ARMReadCPFunc(void *opaque, int cp_info, | |
99 | int dstreg, int operand); | |
100 | ||
f93eb9ff AZ |
101 | struct arm_boot_info; |
102 | ||
c1e37810 | 103 | #define NB_MMU_MODES 7 |
6ebbf390 | 104 | |
b7bcbe95 FB |
105 | /* We currently assume float and double are IEEE single and double |
106 | precision respectively. | |
107 | Doing runtime conversions is tricky because VFP registers may contain | |
108 | integer values (eg. as the result of a FTOSI instruction). | |
8e96005d FB |
109 | s<2n> maps to the least significant half of d<n> |
110 | s<2n+1> maps to the most significant half of d<n> | |
111 | */ | |
b7bcbe95 | 112 | |
55d284af PM |
113 | /* CPU state for each instance of a generic timer (in cp15 c14) */ |
114 | typedef struct ARMGenericTimer { | |
115 | uint64_t cval; /* Timer CompareValue register */ | |
a7adc4b7 | 116 | uint64_t ctl; /* Timer Control register */ |
55d284af PM |
117 | } ARMGenericTimer; |
118 | ||
119 | #define GTIMER_PHYS 0 | |
120 | #define GTIMER_VIRT 1 | |
121 | #define NUM_GTIMERS 2 | |
122 | ||
11f136ee FA |
123 | typedef struct { |
124 | uint64_t raw_tcr; | |
125 | uint32_t mask; | |
126 | uint32_t base_mask; | |
127 | } TCR; | |
128 | ||
2c0262af | 129 | typedef struct CPUARMState { |
b5ff1b31 | 130 | /* Regs for current mode. */ |
2c0262af | 131 | uint32_t regs[16]; |
3926cc84 AG |
132 | |
133 | /* 32/64 switch only happens when taking and returning from | |
134 | * exceptions so the overlap semantics are taken care of then | |
135 | * instead of having a complicated union. | |
136 | */ | |
137 | /* Regs for A64 mode. */ | |
138 | uint64_t xregs[32]; | |
139 | uint64_t pc; | |
d356312f PM |
140 | /* PSTATE isn't an architectural register for ARMv8. However, it is |
141 | * convenient for us to assemble the underlying state into a 32 bit format | |
142 | * identical to the architectural format used for the SPSR. (This is also | |
143 | * what the Linux kernel's 'pstate' field in signal handlers and KVM's | |
144 | * 'pstate' register are.) Of the PSTATE bits: | |
145 | * NZCV are kept in the split out env->CF/VF/NF/ZF, (which have the same | |
146 | * semantics as for AArch32, as described in the comments on each field) | |
147 | * nRW (also known as M[4]) is kept, inverted, in env->aarch64 | |
4cc35614 | 148 | * DAIF (exception masks) are kept in env->daif |
d356312f | 149 | * all other bits are stored in their correct places in env->pstate |
3926cc84 AG |
150 | */ |
151 | uint32_t pstate; | |
152 | uint32_t aarch64; /* 1 if CPU is in aarch64 state; inverse of PSTATE.nRW */ | |
153 | ||
b90372ad | 154 | /* Frequently accessed CPSR bits are stored separately for efficiency. |
d37aca66 | 155 | This contains all the other bits. Use cpsr_{read,write} to access |
b5ff1b31 FB |
156 | the whole CPSR. */ |
157 | uint32_t uncached_cpsr; | |
158 | uint32_t spsr; | |
159 | ||
160 | /* Banked registers. */ | |
28c9457d | 161 | uint64_t banked_spsr[8]; |
0b7d409d FA |
162 | uint32_t banked_r13[8]; |
163 | uint32_t banked_r14[8]; | |
3b46e624 | 164 | |
b5ff1b31 FB |
165 | /* These hold r8-r12. */ |
166 | uint32_t usr_regs[5]; | |
167 | uint32_t fiq_regs[5]; | |
3b46e624 | 168 | |
2c0262af FB |
169 | /* cpsr flag cache for faster execution */ |
170 | uint32_t CF; /* 0 or 1 */ | |
171 | uint32_t VF; /* V is the bit 31. All other bits are undefined */ | |
6fbe23d5 PB |
172 | uint32_t NF; /* N is bit 31. All other bits are undefined. */ |
173 | uint32_t ZF; /* Z set if zero. */ | |
99c475ab | 174 | uint32_t QF; /* 0 or 1 */ |
9ee6e8bb | 175 | uint32_t GE; /* cpsr[19:16] */ |
b26eefb6 | 176 | uint32_t thumb; /* cpsr[5]. 0 = arm mode, 1 = thumb mode. */ |
9ee6e8bb | 177 | uint32_t condexec_bits; /* IT bits. cpsr[15:10,26:25]. */ |
c2b820fe | 178 | uint64_t daif; /* exception masks, in the bits they are in in PSTATE */ |
2c0262af | 179 | |
1b174238 | 180 | uint64_t elr_el[4]; /* AArch64 exception link regs */ |
73fb3b76 | 181 | uint64_t sp_el[4]; /* AArch64 banked stack pointers */ |
a0618a19 | 182 | |
b5ff1b31 FB |
183 | /* System control coprocessor (cp15) */ |
184 | struct { | |
40f137e1 | 185 | uint32_t c0_cpuid; |
b85a1fd6 FA |
186 | union { /* Cache size selection */ |
187 | struct { | |
188 | uint64_t _unused_csselr0; | |
189 | uint64_t csselr_ns; | |
190 | uint64_t _unused_csselr1; | |
191 | uint64_t csselr_s; | |
192 | }; | |
193 | uint64_t csselr_el[4]; | |
194 | }; | |
137feaa9 FA |
195 | union { /* System control register. */ |
196 | struct { | |
197 | uint64_t _unused_sctlr; | |
198 | uint64_t sctlr_ns; | |
199 | uint64_t hsctlr; | |
200 | uint64_t sctlr_s; | |
201 | }; | |
202 | uint64_t sctlr_el[4]; | |
203 | }; | |
34222fb8 | 204 | uint64_t c1_coproc; /* Coprocessor access register. */ |
610c3c8a | 205 | uint32_t c1_xscaleauxcr; /* XScale auxiliary control register. */ |
144634ae | 206 | uint64_t sder; /* Secure debug enable register. */ |
77022576 | 207 | uint32_t nsacr; /* Non-secure access control register. */ |
7dd8c9af FA |
208 | union { /* MMU translation table base 0. */ |
209 | struct { | |
210 | uint64_t _unused_ttbr0_0; | |
211 | uint64_t ttbr0_ns; | |
212 | uint64_t _unused_ttbr0_1; | |
213 | uint64_t ttbr0_s; | |
214 | }; | |
215 | uint64_t ttbr0_el[4]; | |
216 | }; | |
217 | union { /* MMU translation table base 1. */ | |
218 | struct { | |
219 | uint64_t _unused_ttbr1_0; | |
220 | uint64_t ttbr1_ns; | |
221 | uint64_t _unused_ttbr1_1; | |
222 | uint64_t ttbr1_s; | |
223 | }; | |
224 | uint64_t ttbr1_el[4]; | |
225 | }; | |
11f136ee FA |
226 | /* MMU translation table base control. */ |
227 | TCR tcr_el[4]; | |
ce819861 PB |
228 | uint32_t c2_data; /* MPU data cachable bits. */ |
229 | uint32_t c2_insn; /* MPU instruction cachable bits. */ | |
0c17d68c FA |
230 | union { /* MMU domain access control register |
231 | * MPU write buffer control. | |
232 | */ | |
233 | struct { | |
234 | uint64_t dacr_ns; | |
235 | uint64_t dacr_s; | |
236 | }; | |
237 | struct { | |
238 | uint64_t dacr32_el2; | |
239 | }; | |
240 | }; | |
7e09797c PM |
241 | uint32_t pmsav5_data_ap; /* PMSAv5 MPU data access permissions */ |
242 | uint32_t pmsav5_insn_ap; /* PMSAv5 MPU insn access permissions */ | |
f149e3e8 | 243 | uint64_t hcr_el2; /* Hypervisor configuration register */ |
64e0e2de | 244 | uint64_t scr_el3; /* Secure configuration register. */ |
88ca1c2d FA |
245 | union { /* Fault status registers. */ |
246 | struct { | |
247 | uint64_t ifsr_ns; | |
248 | uint64_t ifsr_s; | |
249 | }; | |
250 | struct { | |
251 | uint64_t ifsr32_el2; | |
252 | }; | |
253 | }; | |
4a7e2d73 FA |
254 | union { |
255 | struct { | |
256 | uint64_t _unused_dfsr; | |
257 | uint64_t dfsr_ns; | |
258 | uint64_t hsr; | |
259 | uint64_t dfsr_s; | |
260 | }; | |
261 | uint64_t esr_el[4]; | |
262 | }; | |
ce819861 | 263 | uint32_t c6_region[8]; /* MPU base/size registers. */ |
b848ce2b FA |
264 | union { /* Fault address registers. */ |
265 | struct { | |
266 | uint64_t _unused_far0; | |
267 | #ifdef HOST_WORDS_BIGENDIAN | |
268 | uint32_t ifar_ns; | |
269 | uint32_t dfar_ns; | |
270 | uint32_t ifar_s; | |
271 | uint32_t dfar_s; | |
272 | #else | |
273 | uint32_t dfar_ns; | |
274 | uint32_t ifar_ns; | |
275 | uint32_t dfar_s; | |
276 | uint32_t ifar_s; | |
277 | #endif | |
278 | uint64_t _unused_far3; | |
279 | }; | |
280 | uint64_t far_el[4]; | |
281 | }; | |
01c097f7 FA |
282 | union { /* Translation result. */ |
283 | struct { | |
284 | uint64_t _unused_par_0; | |
285 | uint64_t par_ns; | |
286 | uint64_t _unused_par_1; | |
287 | uint64_t par_s; | |
288 | }; | |
289 | uint64_t par_el[4]; | |
290 | }; | |
b5ff1b31 FB |
291 | uint32_t c9_insn; /* Cache lockdown registers. */ |
292 | uint32_t c9_data; | |
8521466b AF |
293 | uint64_t c9_pmcr; /* performance monitor control register */ |
294 | uint64_t c9_pmcnten; /* perf monitor counter enables */ | |
74594c9d PM |
295 | uint32_t c9_pmovsr; /* perf monitor overflow status */ |
296 | uint32_t c9_pmxevtyper; /* perf monitor event type */ | |
297 | uint32_t c9_pmuserenr; /* perf monitor user enable */ | |
298 | uint32_t c9_pminten; /* perf monitor interrupt enables */ | |
be693c87 GB |
299 | union { /* Memory attribute redirection */ |
300 | struct { | |
301 | #ifdef HOST_WORDS_BIGENDIAN | |
302 | uint64_t _unused_mair_0; | |
303 | uint32_t mair1_ns; | |
304 | uint32_t mair0_ns; | |
305 | uint64_t _unused_mair_1; | |
306 | uint32_t mair1_s; | |
307 | uint32_t mair0_s; | |
308 | #else | |
309 | uint64_t _unused_mair_0; | |
310 | uint32_t mair0_ns; | |
311 | uint32_t mair1_ns; | |
312 | uint64_t _unused_mair_1; | |
313 | uint32_t mair0_s; | |
314 | uint32_t mair1_s; | |
315 | #endif | |
316 | }; | |
317 | uint64_t mair_el[4]; | |
318 | }; | |
fb6c91ba GB |
319 | union { /* vector base address register */ |
320 | struct { | |
321 | uint64_t _unused_vbar; | |
322 | uint64_t vbar_ns; | |
323 | uint64_t hvbar; | |
324 | uint64_t vbar_s; | |
325 | }; | |
326 | uint64_t vbar_el[4]; | |
327 | }; | |
e89e51a1 | 328 | uint32_t mvbar; /* (monitor) vector base address register */ |
54bf36ed FA |
329 | struct { /* FCSE PID. */ |
330 | uint32_t fcseidr_ns; | |
331 | uint32_t fcseidr_s; | |
332 | }; | |
333 | union { /* Context ID. */ | |
334 | struct { | |
335 | uint64_t _unused_contextidr_0; | |
336 | uint64_t contextidr_ns; | |
337 | uint64_t _unused_contextidr_1; | |
338 | uint64_t contextidr_s; | |
339 | }; | |
340 | uint64_t contextidr_el[4]; | |
341 | }; | |
342 | union { /* User RW Thread register. */ | |
343 | struct { | |
344 | uint64_t tpidrurw_ns; | |
345 | uint64_t tpidrprw_ns; | |
346 | uint64_t htpidr; | |
347 | uint64_t _tpidr_el3; | |
348 | }; | |
349 | uint64_t tpidr_el[4]; | |
350 | }; | |
351 | /* The secure banks of these registers don't map anywhere */ | |
352 | uint64_t tpidrurw_s; | |
353 | uint64_t tpidrprw_s; | |
354 | uint64_t tpidruro_s; | |
355 | ||
356 | union { /* User RO Thread register. */ | |
357 | uint64_t tpidruro_ns; | |
358 | uint64_t tpidrro_el[1]; | |
359 | }; | |
a7adc4b7 PM |
360 | uint64_t c14_cntfrq; /* Counter Frequency register */ |
361 | uint64_t c14_cntkctl; /* Timer Control register */ | |
55d284af | 362 | ARMGenericTimer c14_timer[NUM_GTIMERS]; |
c1713132 | 363 | uint32_t c15_cpar; /* XScale Coprocessor Access Register */ |
c3d2689d AZ |
364 | uint32_t c15_ticonfig; /* TI925T configuration byte. */ |
365 | uint32_t c15_i_max; /* Maximum D-cache dirty line index. */ | |
366 | uint32_t c15_i_min; /* Minimum D-cache dirty line index. */ | |
367 | uint32_t c15_threadid; /* TI debugger thread-ID. */ | |
7da362d0 ML |
368 | uint32_t c15_config_base_address; /* SCU base address. */ |
369 | uint32_t c15_diagnostic; /* diagnostic register */ | |
370 | uint32_t c15_power_diagnostic; | |
371 | uint32_t c15_power_control; /* power control */ | |
0b45451e PM |
372 | uint64_t dbgbvr[16]; /* breakpoint value registers */ |
373 | uint64_t dbgbcr[16]; /* breakpoint control registers */ | |
374 | uint64_t dbgwvr[16]; /* watchpoint value registers */ | |
375 | uint64_t dbgwcr[16]; /* watchpoint control registers */ | |
3a298203 | 376 | uint64_t mdscr_el1; |
7c2cb42b AF |
377 | /* If the counter is enabled, this stores the last time the counter |
378 | * was reset. Otherwise it stores the counter value | |
379 | */ | |
c92c0687 | 380 | uint64_t c15_ccnt; |
8521466b | 381 | uint64_t pmccfiltr_el0; /* Performance Monitor Filter Register */ |
b5ff1b31 | 382 | } cp15; |
40f137e1 | 383 | |
9ee6e8bb PB |
384 | struct { |
385 | uint32_t other_sp; | |
386 | uint32_t vecbase; | |
387 | uint32_t basepri; | |
388 | uint32_t control; | |
389 | int current_sp; | |
390 | int exception; | |
391 | int pending_exception; | |
9ee6e8bb PB |
392 | } v7m; |
393 | ||
abf1172f PM |
394 | /* Information associated with an exception about to be taken: |
395 | * code which raises an exception must set cs->exception_index and | |
396 | * the relevant parts of this structure; the cpu_do_interrupt function | |
397 | * will then set the guest-visible registers as part of the exception | |
398 | * entry process. | |
399 | */ | |
400 | struct { | |
401 | uint32_t syndrome; /* AArch64 format syndrome register */ | |
402 | uint32_t fsr; /* AArch32 format fault status register info */ | |
403 | uint64_t vaddress; /* virtual addr associated with exception, if any */ | |
404 | /* If we implement EL2 we will also need to store information | |
405 | * about the intermediate physical address for stage 2 faults. | |
406 | */ | |
407 | } exception; | |
408 | ||
fe1479c3 PB |
409 | /* Thumb-2 EE state. */ |
410 | uint32_t teecr; | |
411 | uint32_t teehbr; | |
412 | ||
b7bcbe95 FB |
413 | /* VFP coprocessor state. */ |
414 | struct { | |
3926cc84 AG |
415 | /* VFP/Neon register state. Note that the mapping between S, D and Q |
416 | * views of the register bank differs between AArch64 and AArch32: | |
417 | * In AArch32: | |
418 | * Qn = regs[2n+1]:regs[2n] | |
419 | * Dn = regs[n] | |
420 | * Sn = regs[n/2] bits 31..0 for even n, and bits 63..32 for odd n | |
421 | * (and regs[32] to regs[63] are inaccessible) | |
422 | * In AArch64: | |
423 | * Qn = regs[2n+1]:regs[2n] | |
424 | * Dn = regs[2n] | |
425 | * Sn = regs[2n] bits 31..0 | |
426 | * This corresponds to the architecturally defined mapping between | |
427 | * the two execution states, and means we do not need to explicitly | |
428 | * map these registers when changing states. | |
429 | */ | |
430 | float64 regs[64]; | |
b7bcbe95 | 431 | |
40f137e1 | 432 | uint32_t xregs[16]; |
b7bcbe95 FB |
433 | /* We store these fpcsr fields separately for convenience. */ |
434 | int vec_len; | |
435 | int vec_stride; | |
436 | ||
9ee6e8bb PB |
437 | /* scratch space when Tn are not sufficient. */ |
438 | uint32_t scratch[8]; | |
3b46e624 | 439 | |
3a492f3a PM |
440 | /* fp_status is the "normal" fp status. standard_fp_status retains |
441 | * values corresponding to the ARM "Standard FPSCR Value", ie | |
442 | * default-NaN, flush-to-zero, round-to-nearest and is used by | |
443 | * any operations (generally Neon) which the architecture defines | |
444 | * as controlled by the standard FPSCR value rather than the FPSCR. | |
445 | * | |
446 | * To avoid having to transfer exception bits around, we simply | |
447 | * say that the FPSCR cumulative exception flags are the logical | |
448 | * OR of the flags in the two fp statuses. This relies on the | |
449 | * only thing which needs to read the exception flags being | |
450 | * an explicit FPSCR read. | |
451 | */ | |
53cd6637 | 452 | float_status fp_status; |
3a492f3a | 453 | float_status standard_fp_status; |
b7bcbe95 | 454 | } vfp; |
03d05e2d PM |
455 | uint64_t exclusive_addr; |
456 | uint64_t exclusive_val; | |
457 | uint64_t exclusive_high; | |
9ee6e8bb | 458 | #if defined(CONFIG_USER_ONLY) |
03d05e2d | 459 | uint64_t exclusive_test; |
426f5abc | 460 | uint32_t exclusive_info; |
9ee6e8bb | 461 | #endif |
b7bcbe95 | 462 | |
18c9b560 AZ |
463 | /* iwMMXt coprocessor state. */ |
464 | struct { | |
465 | uint64_t regs[16]; | |
466 | uint64_t val; | |
467 | ||
468 | uint32_t cregs[16]; | |
469 | } iwmmxt; | |
470 | ||
d8fd2954 PB |
471 | /* For mixed endian mode. */ |
472 | bool bswap_code; | |
473 | ||
ce4defa0 PB |
474 | #if defined(CONFIG_USER_ONLY) |
475 | /* For usermode syscall translation. */ | |
476 | int eabi; | |
477 | #endif | |
478 | ||
46747d15 | 479 | struct CPUBreakpoint *cpu_breakpoint[16]; |
9ee98ce8 PM |
480 | struct CPUWatchpoint *cpu_watchpoint[16]; |
481 | ||
a316d335 FB |
482 | CPU_COMMON |
483 | ||
9d551997 | 484 | /* These fields after the common ones so they are preserved on reset. */ |
9ba8c3f4 | 485 | |
581be094 | 486 | /* Internal CPU feature flags. */ |
918f5dca | 487 | uint64_t features; |
581be094 | 488 | |
983fe826 | 489 | void *nvic; |
462a8bc6 | 490 | const struct arm_boot_info *boot_info; |
2c0262af FB |
491 | } CPUARMState; |
492 | ||
778c3a06 AF |
493 | #include "cpu-qom.h" |
494 | ||
495 | ARMCPU *cpu_arm_init(const char *cpu_model); | |
2c0262af | 496 | int cpu_arm_exec(CPUARMState *s); |
9ee6e8bb | 497 | uint32_t do_arm_semihosting(CPUARMState *env); |
b5ff1b31 | 498 | |
3926cc84 AG |
499 | static inline bool is_a64(CPUARMState *env) |
500 | { | |
501 | return env->aarch64; | |
502 | } | |
503 | ||
2c0262af FB |
504 | /* you can call this signal handler from your SIGBUS and SIGSEGV |
505 | signal handlers to inform the virtual CPU of exceptions. non zero | |
506 | is returned if the signal was handled by the virtual CPU. */ | |
5fafdf24 | 507 | int cpu_arm_signal_handler(int host_signum, void *pinfo, |
2c0262af | 508 | void *puc); |
7510454e AF |
509 | int arm_cpu_handle_mmu_fault(CPUState *cpu, vaddr address, int rw, |
510 | int mmu_idx); | |
2c0262af | 511 | |
ec7b4ce4 AF |
512 | /** |
513 | * pmccntr_sync | |
514 | * @env: CPUARMState | |
515 | * | |
516 | * Synchronises the counter in the PMCCNTR. This must always be called twice, | |
517 | * once before any action that might affect the timer and again afterwards. | |
518 | * The function is used to swap the state of the register if required. | |
519 | * This only happens when not in user mode (!CONFIG_USER_ONLY) | |
520 | */ | |
521 | void pmccntr_sync(CPUARMState *env); | |
522 | ||
76e3e1bc PM |
523 | /* SCTLR bit meanings. Several bits have been reused in newer |
524 | * versions of the architecture; in that case we define constants | |
525 | * for both old and new bit meanings. Code which tests against those | |
526 | * bits should probably check or otherwise arrange that the CPU | |
527 | * is the architectural version it expects. | |
528 | */ | |
529 | #define SCTLR_M (1U << 0) | |
530 | #define SCTLR_A (1U << 1) | |
531 | #define SCTLR_C (1U << 2) | |
532 | #define SCTLR_W (1U << 3) /* up to v6; RAO in v7 */ | |
533 | #define SCTLR_SA (1U << 3) | |
534 | #define SCTLR_P (1U << 4) /* up to v5; RAO in v6 and v7 */ | |
535 | #define SCTLR_SA0 (1U << 4) /* v8 onward, AArch64 only */ | |
536 | #define SCTLR_D (1U << 5) /* up to v5; RAO in v6 */ | |
537 | #define SCTLR_CP15BEN (1U << 5) /* v7 onward */ | |
538 | #define SCTLR_L (1U << 6) /* up to v5; RAO in v6 and v7; RAZ in v8 */ | |
539 | #define SCTLR_B (1U << 7) /* up to v6; RAZ in v7 */ | |
540 | #define SCTLR_ITD (1U << 7) /* v8 onward */ | |
541 | #define SCTLR_S (1U << 8) /* up to v6; RAZ in v7 */ | |
542 | #define SCTLR_SED (1U << 8) /* v8 onward */ | |
543 | #define SCTLR_R (1U << 9) /* up to v6; RAZ in v7 */ | |
544 | #define SCTLR_UMA (1U << 9) /* v8 onward, AArch64 only */ | |
545 | #define SCTLR_F (1U << 10) /* up to v6 */ | |
546 | #define SCTLR_SW (1U << 10) /* v7 onward */ | |
547 | #define SCTLR_Z (1U << 11) | |
548 | #define SCTLR_I (1U << 12) | |
549 | #define SCTLR_V (1U << 13) | |
550 | #define SCTLR_RR (1U << 14) /* up to v7 */ | |
551 | #define SCTLR_DZE (1U << 14) /* v8 onward, AArch64 only */ | |
552 | #define SCTLR_L4 (1U << 15) /* up to v6; RAZ in v7 */ | |
553 | #define SCTLR_UCT (1U << 15) /* v8 onward, AArch64 only */ | |
554 | #define SCTLR_DT (1U << 16) /* up to ??, RAO in v6 and v7 */ | |
555 | #define SCTLR_nTWI (1U << 16) /* v8 onward */ | |
556 | #define SCTLR_HA (1U << 17) | |
557 | #define SCTLR_IT (1U << 18) /* up to ??, RAO in v6 and v7 */ | |
558 | #define SCTLR_nTWE (1U << 18) /* v8 onward */ | |
559 | #define SCTLR_WXN (1U << 19) | |
560 | #define SCTLR_ST (1U << 20) /* up to ??, RAZ in v6 */ | |
561 | #define SCTLR_UWXN (1U << 20) /* v7 onward */ | |
562 | #define SCTLR_FI (1U << 21) | |
563 | #define SCTLR_U (1U << 22) | |
564 | #define SCTLR_XP (1U << 23) /* up to v6; v7 onward RAO */ | |
565 | #define SCTLR_VE (1U << 24) /* up to v7 */ | |
566 | #define SCTLR_E0E (1U << 24) /* v8 onward, AArch64 only */ | |
567 | #define SCTLR_EE (1U << 25) | |
568 | #define SCTLR_L2 (1U << 26) /* up to v6, RAZ in v7 */ | |
569 | #define SCTLR_UCI (1U << 26) /* v8 onward, AArch64 only */ | |
570 | #define SCTLR_NMFI (1U << 27) | |
571 | #define SCTLR_TRE (1U << 28) | |
572 | #define SCTLR_AFE (1U << 29) | |
573 | #define SCTLR_TE (1U << 30) | |
574 | ||
78dbbbe4 PM |
575 | #define CPSR_M (0x1fU) |
576 | #define CPSR_T (1U << 5) | |
577 | #define CPSR_F (1U << 6) | |
578 | #define CPSR_I (1U << 7) | |
579 | #define CPSR_A (1U << 8) | |
580 | #define CPSR_E (1U << 9) | |
581 | #define CPSR_IT_2_7 (0xfc00U) | |
582 | #define CPSR_GE (0xfU << 16) | |
4051e12c PM |
583 | #define CPSR_IL (1U << 20) |
584 | /* Note that the RESERVED bits include bit 21, which is PSTATE_SS in | |
585 | * an AArch64 SPSR but RES0 in AArch32 SPSR and CPSR. In QEMU we use | |
586 | * env->uncached_cpsr bit 21 to store PSTATE.SS when executing in AArch32, | |
587 | * where it is live state but not accessible to the AArch32 code. | |
588 | */ | |
589 | #define CPSR_RESERVED (0x7U << 21) | |
78dbbbe4 PM |
590 | #define CPSR_J (1U << 24) |
591 | #define CPSR_IT_0_1 (3U << 25) | |
592 | #define CPSR_Q (1U << 27) | |
593 | #define CPSR_V (1U << 28) | |
594 | #define CPSR_C (1U << 29) | |
595 | #define CPSR_Z (1U << 30) | |
596 | #define CPSR_N (1U << 31) | |
9ee6e8bb | 597 | #define CPSR_NZCV (CPSR_N | CPSR_Z | CPSR_C | CPSR_V) |
4cc35614 | 598 | #define CPSR_AIF (CPSR_A | CPSR_I | CPSR_F) |
9ee6e8bb PB |
599 | |
600 | #define CPSR_IT (CPSR_IT_0_1 | CPSR_IT_2_7) | |
4cc35614 PM |
601 | #define CACHED_CPSR_BITS (CPSR_T | CPSR_AIF | CPSR_GE | CPSR_IT | CPSR_Q \ |
602 | | CPSR_NZCV) | |
9ee6e8bb PB |
603 | /* Bits writable in user mode. */ |
604 | #define CPSR_USER (CPSR_NZCV | CPSR_Q | CPSR_GE) | |
605 | /* Execution state bits. MRS read as zero, MSR writes ignored. */ | |
4051e12c PM |
606 | #define CPSR_EXEC (CPSR_T | CPSR_IT | CPSR_J | CPSR_IL) |
607 | /* Mask of bits which may be set by exception return copying them from SPSR */ | |
608 | #define CPSR_ERET_MASK (~CPSR_RESERVED) | |
b5ff1b31 | 609 | |
e389be16 FA |
610 | #define TTBCR_N (7U << 0) /* TTBCR.EAE==0 */ |
611 | #define TTBCR_T0SZ (7U << 0) /* TTBCR.EAE==1 */ | |
612 | #define TTBCR_PD0 (1U << 4) | |
613 | #define TTBCR_PD1 (1U << 5) | |
614 | #define TTBCR_EPD0 (1U << 7) | |
615 | #define TTBCR_IRGN0 (3U << 8) | |
616 | #define TTBCR_ORGN0 (3U << 10) | |
617 | #define TTBCR_SH0 (3U << 12) | |
618 | #define TTBCR_T1SZ (3U << 16) | |
619 | #define TTBCR_A1 (1U << 22) | |
620 | #define TTBCR_EPD1 (1U << 23) | |
621 | #define TTBCR_IRGN1 (3U << 24) | |
622 | #define TTBCR_ORGN1 (3U << 26) | |
623 | #define TTBCR_SH1 (1U << 28) | |
624 | #define TTBCR_EAE (1U << 31) | |
625 | ||
d356312f PM |
626 | /* Bit definitions for ARMv8 SPSR (PSTATE) format. |
627 | * Only these are valid when in AArch64 mode; in | |
628 | * AArch32 mode SPSRs are basically CPSR-format. | |
629 | */ | |
f502cfc2 | 630 | #define PSTATE_SP (1U) |
d356312f PM |
631 | #define PSTATE_M (0xFU) |
632 | #define PSTATE_nRW (1U << 4) | |
633 | #define PSTATE_F (1U << 6) | |
634 | #define PSTATE_I (1U << 7) | |
635 | #define PSTATE_A (1U << 8) | |
636 | #define PSTATE_D (1U << 9) | |
637 | #define PSTATE_IL (1U << 20) | |
638 | #define PSTATE_SS (1U << 21) | |
639 | #define PSTATE_V (1U << 28) | |
640 | #define PSTATE_C (1U << 29) | |
641 | #define PSTATE_Z (1U << 30) | |
642 | #define PSTATE_N (1U << 31) | |
643 | #define PSTATE_NZCV (PSTATE_N | PSTATE_Z | PSTATE_C | PSTATE_V) | |
4cc35614 PM |
644 | #define PSTATE_DAIF (PSTATE_D | PSTATE_A | PSTATE_I | PSTATE_F) |
645 | #define CACHED_PSTATE_BITS (PSTATE_NZCV | PSTATE_DAIF) | |
d356312f PM |
646 | /* Mode values for AArch64 */ |
647 | #define PSTATE_MODE_EL3h 13 | |
648 | #define PSTATE_MODE_EL3t 12 | |
649 | #define PSTATE_MODE_EL2h 9 | |
650 | #define PSTATE_MODE_EL2t 8 | |
651 | #define PSTATE_MODE_EL1h 5 | |
652 | #define PSTATE_MODE_EL1t 4 | |
653 | #define PSTATE_MODE_EL0t 0 | |
654 | ||
9e729b57 EI |
655 | /* Map EL and handler into a PSTATE_MODE. */ |
656 | static inline unsigned int aarch64_pstate_mode(unsigned int el, bool handler) | |
657 | { | |
658 | return (el << 2) | handler; | |
659 | } | |
660 | ||
d356312f PM |
661 | /* Return the current PSTATE value. For the moment we don't support 32<->64 bit |
662 | * interprocessing, so we don't attempt to sync with the cpsr state used by | |
663 | * the 32 bit decoder. | |
664 | */ | |
665 | static inline uint32_t pstate_read(CPUARMState *env) | |
666 | { | |
667 | int ZF; | |
668 | ||
669 | ZF = (env->ZF == 0); | |
670 | return (env->NF & 0x80000000) | (ZF << 30) | |
671 | | (env->CF << 29) | ((env->VF & 0x80000000) >> 3) | |
4cc35614 | 672 | | env->pstate | env->daif; |
d356312f PM |
673 | } |
674 | ||
675 | static inline void pstate_write(CPUARMState *env, uint32_t val) | |
676 | { | |
677 | env->ZF = (~val) & PSTATE_Z; | |
678 | env->NF = val; | |
679 | env->CF = (val >> 29) & 1; | |
680 | env->VF = (val << 3) & 0x80000000; | |
4cc35614 | 681 | env->daif = val & PSTATE_DAIF; |
d356312f PM |
682 | env->pstate = val & ~CACHED_PSTATE_BITS; |
683 | } | |
684 | ||
b5ff1b31 | 685 | /* Return the current CPSR value. */ |
2f4a40e5 AZ |
686 | uint32_t cpsr_read(CPUARMState *env); |
687 | /* Set the CPSR. Note that some bits of mask must be all-set or all-clear. */ | |
688 | void cpsr_write(CPUARMState *env, uint32_t val, uint32_t mask); | |
9ee6e8bb PB |
689 | |
690 | /* Return the current xPSR value. */ | |
691 | static inline uint32_t xpsr_read(CPUARMState *env) | |
692 | { | |
693 | int ZF; | |
6fbe23d5 PB |
694 | ZF = (env->ZF == 0); |
695 | return (env->NF & 0x80000000) | (ZF << 30) | |
9ee6e8bb PB |
696 | | (env->CF << 29) | ((env->VF & 0x80000000) >> 3) | (env->QF << 27) |
697 | | (env->thumb << 24) | ((env->condexec_bits & 3) << 25) | |
698 | | ((env->condexec_bits & 0xfc) << 8) | |
699 | | env->v7m.exception; | |
b5ff1b31 FB |
700 | } |
701 | ||
9ee6e8bb PB |
702 | /* Set the xPSR. Note that some bits of mask must be all-set or all-clear. */ |
703 | static inline void xpsr_write(CPUARMState *env, uint32_t val, uint32_t mask) | |
704 | { | |
9ee6e8bb | 705 | if (mask & CPSR_NZCV) { |
6fbe23d5 PB |
706 | env->ZF = (~val) & CPSR_Z; |
707 | env->NF = val; | |
9ee6e8bb PB |
708 | env->CF = (val >> 29) & 1; |
709 | env->VF = (val << 3) & 0x80000000; | |
710 | } | |
711 | if (mask & CPSR_Q) | |
712 | env->QF = ((val & CPSR_Q) != 0); | |
713 | if (mask & (1 << 24)) | |
714 | env->thumb = ((val & (1 << 24)) != 0); | |
715 | if (mask & CPSR_IT_0_1) { | |
716 | env->condexec_bits &= ~3; | |
717 | env->condexec_bits |= (val >> 25) & 3; | |
718 | } | |
719 | if (mask & CPSR_IT_2_7) { | |
720 | env->condexec_bits &= 3; | |
721 | env->condexec_bits |= (val >> 8) & 0xfc; | |
722 | } | |
723 | if (mask & 0x1ff) { | |
724 | env->v7m.exception = val & 0x1ff; | |
725 | } | |
726 | } | |
727 | ||
f149e3e8 EI |
728 | #define HCR_VM (1ULL << 0) |
729 | #define HCR_SWIO (1ULL << 1) | |
730 | #define HCR_PTW (1ULL << 2) | |
731 | #define HCR_FMO (1ULL << 3) | |
732 | #define HCR_IMO (1ULL << 4) | |
733 | #define HCR_AMO (1ULL << 5) | |
734 | #define HCR_VF (1ULL << 6) | |
735 | #define HCR_VI (1ULL << 7) | |
736 | #define HCR_VSE (1ULL << 8) | |
737 | #define HCR_FB (1ULL << 9) | |
738 | #define HCR_BSU_MASK (3ULL << 10) | |
739 | #define HCR_DC (1ULL << 12) | |
740 | #define HCR_TWI (1ULL << 13) | |
741 | #define HCR_TWE (1ULL << 14) | |
742 | #define HCR_TID0 (1ULL << 15) | |
743 | #define HCR_TID1 (1ULL << 16) | |
744 | #define HCR_TID2 (1ULL << 17) | |
745 | #define HCR_TID3 (1ULL << 18) | |
746 | #define HCR_TSC (1ULL << 19) | |
747 | #define HCR_TIDCP (1ULL << 20) | |
748 | #define HCR_TACR (1ULL << 21) | |
749 | #define HCR_TSW (1ULL << 22) | |
750 | #define HCR_TPC (1ULL << 23) | |
751 | #define HCR_TPU (1ULL << 24) | |
752 | #define HCR_TTLB (1ULL << 25) | |
753 | #define HCR_TVM (1ULL << 26) | |
754 | #define HCR_TGE (1ULL << 27) | |
755 | #define HCR_TDZ (1ULL << 28) | |
756 | #define HCR_HCD (1ULL << 29) | |
757 | #define HCR_TRVM (1ULL << 30) | |
758 | #define HCR_RW (1ULL << 31) | |
759 | #define HCR_CD (1ULL << 32) | |
760 | #define HCR_ID (1ULL << 33) | |
761 | #define HCR_MASK ((1ULL << 34) - 1) | |
762 | ||
64e0e2de EI |
763 | #define SCR_NS (1U << 0) |
764 | #define SCR_IRQ (1U << 1) | |
765 | #define SCR_FIQ (1U << 2) | |
766 | #define SCR_EA (1U << 3) | |
767 | #define SCR_FW (1U << 4) | |
768 | #define SCR_AW (1U << 5) | |
769 | #define SCR_NET (1U << 6) | |
770 | #define SCR_SMD (1U << 7) | |
771 | #define SCR_HCE (1U << 8) | |
772 | #define SCR_SIF (1U << 9) | |
773 | #define SCR_RW (1U << 10) | |
774 | #define SCR_ST (1U << 11) | |
775 | #define SCR_TWI (1U << 12) | |
776 | #define SCR_TWE (1U << 13) | |
777 | #define SCR_AARCH32_MASK (0x3fff & ~(SCR_RW | SCR_ST)) | |
778 | #define SCR_AARCH64_MASK (0x3fff & ~SCR_NET) | |
779 | ||
01653295 PM |
780 | /* Return the current FPSCR value. */ |
781 | uint32_t vfp_get_fpscr(CPUARMState *env); | |
782 | void vfp_set_fpscr(CPUARMState *env, uint32_t val); | |
783 | ||
f903fa22 PM |
784 | /* For A64 the FPSCR is split into two logically distinct registers, |
785 | * FPCR and FPSR. However since they still use non-overlapping bits | |
786 | * we store the underlying state in fpscr and just mask on read/write. | |
787 | */ | |
788 | #define FPSR_MASK 0xf800009f | |
789 | #define FPCR_MASK 0x07f79f00 | |
790 | static inline uint32_t vfp_get_fpsr(CPUARMState *env) | |
791 | { | |
792 | return vfp_get_fpscr(env) & FPSR_MASK; | |
793 | } | |
794 | ||
795 | static inline void vfp_set_fpsr(CPUARMState *env, uint32_t val) | |
796 | { | |
797 | uint32_t new_fpscr = (vfp_get_fpscr(env) & ~FPSR_MASK) | (val & FPSR_MASK); | |
798 | vfp_set_fpscr(env, new_fpscr); | |
799 | } | |
800 | ||
801 | static inline uint32_t vfp_get_fpcr(CPUARMState *env) | |
802 | { | |
803 | return vfp_get_fpscr(env) & FPCR_MASK; | |
804 | } | |
805 | ||
806 | static inline void vfp_set_fpcr(CPUARMState *env, uint32_t val) | |
807 | { | |
808 | uint32_t new_fpscr = (vfp_get_fpscr(env) & ~FPCR_MASK) | (val & FPCR_MASK); | |
809 | vfp_set_fpscr(env, new_fpscr); | |
810 | } | |
811 | ||
b5ff1b31 FB |
812 | enum arm_cpu_mode { |
813 | ARM_CPU_MODE_USR = 0x10, | |
814 | ARM_CPU_MODE_FIQ = 0x11, | |
815 | ARM_CPU_MODE_IRQ = 0x12, | |
816 | ARM_CPU_MODE_SVC = 0x13, | |
28c9457d | 817 | ARM_CPU_MODE_MON = 0x16, |
b5ff1b31 | 818 | ARM_CPU_MODE_ABT = 0x17, |
28c9457d | 819 | ARM_CPU_MODE_HYP = 0x1a, |
b5ff1b31 FB |
820 | ARM_CPU_MODE_UND = 0x1b, |
821 | ARM_CPU_MODE_SYS = 0x1f | |
822 | }; | |
823 | ||
40f137e1 PB |
824 | /* VFP system registers. */ |
825 | #define ARM_VFP_FPSID 0 | |
826 | #define ARM_VFP_FPSCR 1 | |
a50c0f51 | 827 | #define ARM_VFP_MVFR2 5 |
9ee6e8bb PB |
828 | #define ARM_VFP_MVFR1 6 |
829 | #define ARM_VFP_MVFR0 7 | |
40f137e1 PB |
830 | #define ARM_VFP_FPEXC 8 |
831 | #define ARM_VFP_FPINST 9 | |
832 | #define ARM_VFP_FPINST2 10 | |
833 | ||
18c9b560 AZ |
834 | /* iwMMXt coprocessor control registers. */ |
835 | #define ARM_IWMMXT_wCID 0 | |
836 | #define ARM_IWMMXT_wCon 1 | |
837 | #define ARM_IWMMXT_wCSSF 2 | |
838 | #define ARM_IWMMXT_wCASF 3 | |
839 | #define ARM_IWMMXT_wCGR0 8 | |
840 | #define ARM_IWMMXT_wCGR1 9 | |
841 | #define ARM_IWMMXT_wCGR2 10 | |
842 | #define ARM_IWMMXT_wCGR3 11 | |
843 | ||
ce854d7c BC |
844 | /* If adding a feature bit which corresponds to a Linux ELF |
845 | * HWCAP bit, remember to update the feature-bit-to-hwcap | |
846 | * mapping in linux-user/elfload.c:get_elf_hwcap(). | |
847 | */ | |
40f137e1 PB |
848 | enum arm_features { |
849 | ARM_FEATURE_VFP, | |
c1713132 AZ |
850 | ARM_FEATURE_AUXCR, /* ARM1026 Auxiliary control register. */ |
851 | ARM_FEATURE_XSCALE, /* Intel XScale extensions. */ | |
ce819861 | 852 | ARM_FEATURE_IWMMXT, /* Intel iwMMXt extension. */ |
9ee6e8bb PB |
853 | ARM_FEATURE_V6, |
854 | ARM_FEATURE_V6K, | |
855 | ARM_FEATURE_V7, | |
856 | ARM_FEATURE_THUMB2, | |
c3d2689d | 857 | ARM_FEATURE_MPU, /* Only has Memory Protection Unit, not full MMU. */ |
9ee6e8bb | 858 | ARM_FEATURE_VFP3, |
60011498 | 859 | ARM_FEATURE_VFP_FP16, |
9ee6e8bb | 860 | ARM_FEATURE_NEON, |
47789990 | 861 | ARM_FEATURE_THUMB_DIV, /* divide supported in Thumb encoding */ |
9ee6e8bb | 862 | ARM_FEATURE_M, /* Microcontroller profile. */ |
fe1479c3 | 863 | ARM_FEATURE_OMAPCP, /* OMAP specific CP15 ops handling. */ |
e1bbf446 | 864 | ARM_FEATURE_THUMB2EE, |
be5e7a76 DES |
865 | ARM_FEATURE_V7MP, /* v7 Multiprocessing Extensions */ |
866 | ARM_FEATURE_V4T, | |
867 | ARM_FEATURE_V5, | |
5bc95aa2 | 868 | ARM_FEATURE_STRONGARM, |
906879a9 | 869 | ARM_FEATURE_VAPA, /* cp15 VA to PA lookups */ |
b8b8ea05 | 870 | ARM_FEATURE_ARM_DIV, /* divide supported in ARM encoding */ |
da97f52c | 871 | ARM_FEATURE_VFP4, /* VFPv4 (implies that NEON is v2) */ |
0383ac00 | 872 | ARM_FEATURE_GENERIC_TIMER, |
06ed5d66 | 873 | ARM_FEATURE_MVFR, /* Media and VFP Feature Registers 0 and 1 */ |
1047b9d7 | 874 | ARM_FEATURE_DUMMY_C15_REGS, /* RAZ/WI all of cp15 crn=15 */ |
c4804214 PM |
875 | ARM_FEATURE_CACHE_TEST_CLEAN, /* 926/1026 style test-and-clean ops */ |
876 | ARM_FEATURE_CACHE_DIRTY_REG, /* 1136/1176 cache dirty status register */ | |
877 | ARM_FEATURE_CACHE_BLOCK_OPS, /* v6 optional cache block operations */ | |
81bdde9d | 878 | ARM_FEATURE_MPIDR, /* has cp15 MPIDR */ |
de9b05b8 PM |
879 | ARM_FEATURE_PXN, /* has Privileged Execute Never bit */ |
880 | ARM_FEATURE_LPAE, /* has Large Physical Address Extension */ | |
81e69fb0 | 881 | ARM_FEATURE_V8, |
3926cc84 | 882 | ARM_FEATURE_AARCH64, /* supports 64 bit mode */ |
9d935509 | 883 | ARM_FEATURE_V8_AES, /* implements AES part of v8 Crypto Extensions */ |
d8ba780b | 884 | ARM_FEATURE_CBAR, /* has cp15 CBAR */ |
eb0ecd5a | 885 | ARM_FEATURE_CRC, /* ARMv8 CRC instructions */ |
f318cec6 | 886 | ARM_FEATURE_CBAR_RO, /* has cp15 CBAR and it is read-only */ |
cca7c2f5 | 887 | ARM_FEATURE_EL2, /* has EL2 Virtualization support */ |
1fe8141e | 888 | ARM_FEATURE_EL3, /* has EL3 Secure monitor support */ |
f1ecb913 AB |
889 | ARM_FEATURE_V8_SHA1, /* implements SHA1 part of v8 Crypto Extensions */ |
890 | ARM_FEATURE_V8_SHA256, /* implements SHA256 part of v8 Crypto Extensions */ | |
4e624eda | 891 | ARM_FEATURE_V8_PMULL, /* implements PMULL part of v8 Crypto Extensions */ |
40f137e1 PB |
892 | }; |
893 | ||
894 | static inline int arm_feature(CPUARMState *env, int feature) | |
895 | { | |
918f5dca | 896 | return (env->features & (1ULL << feature)) != 0; |
40f137e1 PB |
897 | } |
898 | ||
19e0fefa FA |
899 | #if !defined(CONFIG_USER_ONLY) |
900 | /* Return true if exception levels below EL3 are in secure state, | |
901 | * or would be following an exception return to that level. | |
902 | * Unlike arm_is_secure() (which is always a question about the | |
903 | * _current_ state of the CPU) this doesn't care about the current | |
904 | * EL or mode. | |
905 | */ | |
906 | static inline bool arm_is_secure_below_el3(CPUARMState *env) | |
907 | { | |
908 | if (arm_feature(env, ARM_FEATURE_EL3)) { | |
909 | return !(env->cp15.scr_el3 & SCR_NS); | |
910 | } else { | |
911 | /* If EL2 is not supported then the secure state is implementation | |
912 | * defined, in which case QEMU defaults to non-secure. | |
913 | */ | |
914 | return false; | |
915 | } | |
916 | } | |
917 | ||
918 | /* Return true if the processor is in secure state */ | |
919 | static inline bool arm_is_secure(CPUARMState *env) | |
920 | { | |
921 | if (arm_feature(env, ARM_FEATURE_EL3)) { | |
922 | if (is_a64(env) && extract32(env->pstate, 2, 2) == 3) { | |
923 | /* CPU currently in AArch64 state and EL3 */ | |
924 | return true; | |
925 | } else if (!is_a64(env) && | |
926 | (env->uncached_cpsr & CPSR_M) == ARM_CPU_MODE_MON) { | |
927 | /* CPU currently in AArch32 state and monitor mode */ | |
928 | return true; | |
929 | } | |
930 | } | |
931 | return arm_is_secure_below_el3(env); | |
932 | } | |
933 | ||
934 | #else | |
935 | static inline bool arm_is_secure_below_el3(CPUARMState *env) | |
936 | { | |
937 | return false; | |
938 | } | |
939 | ||
940 | static inline bool arm_is_secure(CPUARMState *env) | |
941 | { | |
942 | return false; | |
943 | } | |
944 | #endif | |
945 | ||
1f79ee32 PM |
946 | /* Return true if the specified exception level is running in AArch64 state. */ |
947 | static inline bool arm_el_is_aa64(CPUARMState *env, int el) | |
948 | { | |
592125f8 | 949 | /* We don't currently support EL2, and this isn't valid for EL0 |
1f79ee32 PM |
950 | * (if we're in EL0, is_a64() is what you want, and if we're not in EL0 |
951 | * then the state of EL0 isn't well defined.) | |
952 | */ | |
592125f8 FA |
953 | assert(el == 1 || el == 3); |
954 | ||
1f79ee32 PM |
955 | /* AArch64-capable CPUs always run with EL1 in AArch64 mode. This |
956 | * is a QEMU-imposed simplification which we may wish to change later. | |
957 | * If we in future support EL2 and/or EL3, then the state of lower | |
958 | * exception levels is controlled by the HCR.RW and SCR.RW bits. | |
959 | */ | |
960 | return arm_feature(env, ARM_FEATURE_AARCH64); | |
961 | } | |
962 | ||
3f342b9e SF |
963 | /* Function for determing whether guest cp register reads and writes should |
964 | * access the secure or non-secure bank of a cp register. When EL3 is | |
965 | * operating in AArch32 state, the NS-bit determines whether the secure | |
966 | * instance of a cp register should be used. When EL3 is AArch64 (or if | |
967 | * it doesn't exist at all) then there is no register banking, and all | |
968 | * accesses are to the non-secure version. | |
969 | */ | |
970 | static inline bool access_secure_reg(CPUARMState *env) | |
971 | { | |
972 | bool ret = (arm_feature(env, ARM_FEATURE_EL3) && | |
973 | !arm_el_is_aa64(env, 3) && | |
974 | !(env->cp15.scr_el3 & SCR_NS)); | |
975 | ||
976 | return ret; | |
977 | } | |
978 | ||
ea30a4b8 FA |
979 | /* Macros for accessing a specified CP register bank */ |
980 | #define A32_BANKED_REG_GET(_env, _regname, _secure) \ | |
981 | ((_secure) ? (_env)->cp15._regname##_s : (_env)->cp15._regname##_ns) | |
982 | ||
983 | #define A32_BANKED_REG_SET(_env, _regname, _secure, _val) \ | |
984 | do { \ | |
985 | if (_secure) { \ | |
986 | (_env)->cp15._regname##_s = (_val); \ | |
987 | } else { \ | |
988 | (_env)->cp15._regname##_ns = (_val); \ | |
989 | } \ | |
990 | } while (0) | |
991 | ||
992 | /* Macros for automatically accessing a specific CP register bank depending on | |
993 | * the current secure state of the system. These macros are not intended for | |
994 | * supporting instruction translation reads/writes as these are dependent | |
995 | * solely on the SCR.NS bit and not the mode. | |
996 | */ | |
997 | #define A32_BANKED_CURRENT_REG_GET(_env, _regname) \ | |
998 | A32_BANKED_REG_GET((_env), _regname, \ | |
999 | ((!arm_el_is_aa64((_env), 3) && arm_is_secure(_env)))) | |
1000 | ||
1001 | #define A32_BANKED_CURRENT_REG_SET(_env, _regname, _val) \ | |
1002 | A32_BANKED_REG_SET((_env), _regname, \ | |
1003 | ((!arm_el_is_aa64((_env), 3) && arm_is_secure(_env))), \ | |
1004 | (_val)) | |
1005 | ||
9a78eead | 1006 | void arm_cpu_list(FILE *f, fprintf_function cpu_fprintf); |
9e729b57 | 1007 | unsigned int arm_excp_target_el(CPUState *cs, unsigned int excp_idx); |
40f137e1 | 1008 | |
9ee6e8bb PB |
1009 | /* Interface between CPU and Interrupt controller. */ |
1010 | void armv7m_nvic_set_pending(void *opaque, int irq); | |
1011 | int armv7m_nvic_acknowledge_irq(void *opaque); | |
1012 | void armv7m_nvic_complete_irq(void *opaque, int irq); | |
1013 | ||
4b6a83fb PM |
1014 | /* Interface for defining coprocessor registers. |
1015 | * Registers are defined in tables of arm_cp_reginfo structs | |
1016 | * which are passed to define_arm_cp_regs(). | |
1017 | */ | |
1018 | ||
1019 | /* When looking up a coprocessor register we look for it | |
1020 | * via an integer which encodes all of: | |
1021 | * coprocessor number | |
1022 | * Crn, Crm, opc1, opc2 fields | |
1023 | * 32 or 64 bit register (ie is it accessed via MRC/MCR | |
1024 | * or via MRRC/MCRR?) | |
51a79b03 | 1025 | * non-secure/secure bank (AArch32 only) |
4b6a83fb PM |
1026 | * We allow 4 bits for opc1 because MRRC/MCRR have a 4 bit field. |
1027 | * (In this case crn and opc2 should be zero.) | |
f5a0a5a5 PM |
1028 | * For AArch64, there is no 32/64 bit size distinction; |
1029 | * instead all registers have a 2 bit op0, 3 bit op1 and op2, | |
1030 | * and 4 bit CRn and CRm. The encoding patterns are chosen | |
1031 | * to be easy to convert to and from the KVM encodings, and also | |
1032 | * so that the hashtable can contain both AArch32 and AArch64 | |
1033 | * registers (to allow for interprocessing where we might run | |
1034 | * 32 bit code on a 64 bit core). | |
4b6a83fb | 1035 | */ |
f5a0a5a5 PM |
1036 | /* This bit is private to our hashtable cpreg; in KVM register |
1037 | * IDs the AArch64/32 distinction is the KVM_REG_ARM/ARM64 | |
1038 | * in the upper bits of the 64 bit ID. | |
1039 | */ | |
1040 | #define CP_REG_AA64_SHIFT 28 | |
1041 | #define CP_REG_AA64_MASK (1 << CP_REG_AA64_SHIFT) | |
1042 | ||
51a79b03 PM |
1043 | /* To enable banking of coprocessor registers depending on ns-bit we |
1044 | * add a bit to distinguish between secure and non-secure cpregs in the | |
1045 | * hashtable. | |
1046 | */ | |
1047 | #define CP_REG_NS_SHIFT 29 | |
1048 | #define CP_REG_NS_MASK (1 << CP_REG_NS_SHIFT) | |
1049 | ||
1050 | #define ENCODE_CP_REG(cp, is64, ns, crn, crm, opc1, opc2) \ | |
1051 | ((ns) << CP_REG_NS_SHIFT | ((cp) << 16) | ((is64) << 15) | \ | |
1052 | ((crn) << 11) | ((crm) << 7) | ((opc1) << 3) | (opc2)) | |
4b6a83fb | 1053 | |
f5a0a5a5 PM |
1054 | #define ENCODE_AA64_CP_REG(cp, crn, crm, op0, op1, op2) \ |
1055 | (CP_REG_AA64_MASK | \ | |
1056 | ((cp) << CP_REG_ARM_COPROC_SHIFT) | \ | |
1057 | ((op0) << CP_REG_ARM64_SYSREG_OP0_SHIFT) | \ | |
1058 | ((op1) << CP_REG_ARM64_SYSREG_OP1_SHIFT) | \ | |
1059 | ((crn) << CP_REG_ARM64_SYSREG_CRN_SHIFT) | \ | |
1060 | ((crm) << CP_REG_ARM64_SYSREG_CRM_SHIFT) | \ | |
1061 | ((op2) << CP_REG_ARM64_SYSREG_OP2_SHIFT)) | |
1062 | ||
721fae12 PM |
1063 | /* Convert a full 64 bit KVM register ID to the truncated 32 bit |
1064 | * version used as a key for the coprocessor register hashtable | |
1065 | */ | |
1066 | static inline uint32_t kvm_to_cpreg_id(uint64_t kvmid) | |
1067 | { | |
1068 | uint32_t cpregid = kvmid; | |
f5a0a5a5 PM |
1069 | if ((kvmid & CP_REG_ARCH_MASK) == CP_REG_ARM64) { |
1070 | cpregid |= CP_REG_AA64_MASK; | |
51a79b03 PM |
1071 | } else { |
1072 | if ((kvmid & CP_REG_SIZE_MASK) == CP_REG_SIZE_U64) { | |
1073 | cpregid |= (1 << 15); | |
1074 | } | |
1075 | ||
1076 | /* KVM is always non-secure so add the NS flag on AArch32 register | |
1077 | * entries. | |
1078 | */ | |
1079 | cpregid |= 1 << CP_REG_NS_SHIFT; | |
721fae12 PM |
1080 | } |
1081 | return cpregid; | |
1082 | } | |
1083 | ||
1084 | /* Convert a truncated 32 bit hashtable key into the full | |
1085 | * 64 bit KVM register ID. | |
1086 | */ | |
1087 | static inline uint64_t cpreg_to_kvm_id(uint32_t cpregid) | |
1088 | { | |
f5a0a5a5 PM |
1089 | uint64_t kvmid; |
1090 | ||
1091 | if (cpregid & CP_REG_AA64_MASK) { | |
1092 | kvmid = cpregid & ~CP_REG_AA64_MASK; | |
1093 | kvmid |= CP_REG_SIZE_U64 | CP_REG_ARM64; | |
721fae12 | 1094 | } else { |
f5a0a5a5 PM |
1095 | kvmid = cpregid & ~(1 << 15); |
1096 | if (cpregid & (1 << 15)) { | |
1097 | kvmid |= CP_REG_SIZE_U64 | CP_REG_ARM; | |
1098 | } else { | |
1099 | kvmid |= CP_REG_SIZE_U32 | CP_REG_ARM; | |
1100 | } | |
721fae12 PM |
1101 | } |
1102 | return kvmid; | |
1103 | } | |
1104 | ||
4b6a83fb PM |
1105 | /* ARMCPRegInfo type field bits. If the SPECIAL bit is set this is a |
1106 | * special-behaviour cp reg and bits [15..8] indicate what behaviour | |
1107 | * it has. Otherwise it is a simple cp reg, where CONST indicates that | |
1108 | * TCG can assume the value to be constant (ie load at translate time) | |
1109 | * and 64BIT indicates a 64 bit wide coprocessor register. SUPPRESS_TB_END | |
1110 | * indicates that the TB should not be ended after a write to this register | |
1111 | * (the default is that the TB ends after cp writes). OVERRIDE permits | |
1112 | * a register definition to override a previous definition for the | |
1113 | * same (cp, is64, crn, crm, opc1, opc2) tuple: either the new or the | |
1114 | * old must have the OVERRIDE bit set. | |
7a0e58fa PM |
1115 | * ALIAS indicates that this register is an alias view of some underlying |
1116 | * state which is also visible via another register, and that the other | |
1117 | * register is handling migration; registers marked ALIAS will not be migrated | |
1118 | * but may have their state set by syncing of register state from KVM. | |
1119 | * NO_RAW indicates that this register has no underlying state and does not | |
1120 | * support raw access for state saving/loading; it will not be used for either | |
1121 | * migration or KVM state synchronization. (Typically this is for "registers" | |
1122 | * which are actually used as instructions for cache maintenance and so on.) | |
2452731c PM |
1123 | * IO indicates that this register does I/O and therefore its accesses |
1124 | * need to be surrounded by gen_io_start()/gen_io_end(). In particular, | |
1125 | * registers which implement clocks or timers require this. | |
4b6a83fb PM |
1126 | */ |
1127 | #define ARM_CP_SPECIAL 1 | |
1128 | #define ARM_CP_CONST 2 | |
1129 | #define ARM_CP_64BIT 4 | |
1130 | #define ARM_CP_SUPPRESS_TB_END 8 | |
1131 | #define ARM_CP_OVERRIDE 16 | |
7a0e58fa | 1132 | #define ARM_CP_ALIAS 32 |
2452731c | 1133 | #define ARM_CP_IO 64 |
7a0e58fa | 1134 | #define ARM_CP_NO_RAW 128 |
4b6a83fb PM |
1135 | #define ARM_CP_NOP (ARM_CP_SPECIAL | (1 << 8)) |
1136 | #define ARM_CP_WFI (ARM_CP_SPECIAL | (2 << 8)) | |
b0d2b7d0 | 1137 | #define ARM_CP_NZCV (ARM_CP_SPECIAL | (3 << 8)) |
0eef9d98 | 1138 | #define ARM_CP_CURRENTEL (ARM_CP_SPECIAL | (4 << 8)) |
aca3f40b PM |
1139 | #define ARM_CP_DC_ZVA (ARM_CP_SPECIAL | (5 << 8)) |
1140 | #define ARM_LAST_SPECIAL ARM_CP_DC_ZVA | |
4b6a83fb PM |
1141 | /* Used only as a terminator for ARMCPRegInfo lists */ |
1142 | #define ARM_CP_SENTINEL 0xffff | |
1143 | /* Mask of only the flag bits in a type field */ | |
7a0e58fa | 1144 | #define ARM_CP_FLAG_MASK 0xff |
4b6a83fb | 1145 | |
f5a0a5a5 PM |
1146 | /* Valid values for ARMCPRegInfo state field, indicating which of |
1147 | * the AArch32 and AArch64 execution states this register is visible in. | |
1148 | * If the reginfo doesn't explicitly specify then it is AArch32 only. | |
1149 | * If the reginfo is declared to be visible in both states then a second | |
1150 | * reginfo is synthesised for the AArch32 view of the AArch64 register, | |
1151 | * such that the AArch32 view is the lower 32 bits of the AArch64 one. | |
1152 | * Note that we rely on the values of these enums as we iterate through | |
1153 | * the various states in some places. | |
1154 | */ | |
1155 | enum { | |
1156 | ARM_CP_STATE_AA32 = 0, | |
1157 | ARM_CP_STATE_AA64 = 1, | |
1158 | ARM_CP_STATE_BOTH = 2, | |
1159 | }; | |
1160 | ||
c3e30260 FA |
1161 | /* ARM CP register secure state flags. These flags identify security state |
1162 | * attributes for a given CP register entry. | |
1163 | * The existence of both or neither secure and non-secure flags indicates that | |
1164 | * the register has both a secure and non-secure hash entry. A single one of | |
1165 | * these flags causes the register to only be hashed for the specified | |
1166 | * security state. | |
1167 | * Although definitions may have any combination of the S/NS bits, each | |
1168 | * registered entry will only have one to identify whether the entry is secure | |
1169 | * or non-secure. | |
1170 | */ | |
1171 | enum { | |
1172 | ARM_CP_SECSTATE_S = (1 << 0), /* bit[0]: Secure state register */ | |
1173 | ARM_CP_SECSTATE_NS = (1 << 1), /* bit[1]: Non-secure state register */ | |
1174 | }; | |
1175 | ||
4b6a83fb PM |
1176 | /* Return true if cptype is a valid type field. This is used to try to |
1177 | * catch errors where the sentinel has been accidentally left off the end | |
1178 | * of a list of registers. | |
1179 | */ | |
1180 | static inline bool cptype_valid(int cptype) | |
1181 | { | |
1182 | return ((cptype & ~ARM_CP_FLAG_MASK) == 0) | |
1183 | || ((cptype & ARM_CP_SPECIAL) && | |
34affeef | 1184 | ((cptype & ~ARM_CP_FLAG_MASK) <= ARM_LAST_SPECIAL)); |
4b6a83fb PM |
1185 | } |
1186 | ||
1187 | /* Access rights: | |
1188 | * We define bits for Read and Write access for what rev C of the v7-AR ARM ARM | |
1189 | * defines as PL0 (user), PL1 (fiq/irq/svc/abt/und/sys, ie privileged), and | |
1190 | * PL2 (hyp). The other level which has Read and Write bits is Secure PL1 | |
1191 | * (ie any of the privileged modes in Secure state, or Monitor mode). | |
1192 | * If a register is accessible in one privilege level it's always accessible | |
1193 | * in higher privilege levels too. Since "Secure PL1" also follows this rule | |
1194 | * (ie anything visible in PL2 is visible in S-PL1, some things are only | |
1195 | * visible in S-PL1) but "Secure PL1" is a bit of a mouthful, we bend the | |
1196 | * terminology a little and call this PL3. | |
f5a0a5a5 PM |
1197 | * In AArch64 things are somewhat simpler as the PLx bits line up exactly |
1198 | * with the ELx exception levels. | |
4b6a83fb PM |
1199 | * |
1200 | * If access permissions for a register are more complex than can be | |
1201 | * described with these bits, then use a laxer set of restrictions, and | |
1202 | * do the more restrictive/complex check inside a helper function. | |
1203 | */ | |
1204 | #define PL3_R 0x80 | |
1205 | #define PL3_W 0x40 | |
1206 | #define PL2_R (0x20 | PL3_R) | |
1207 | #define PL2_W (0x10 | PL3_W) | |
1208 | #define PL1_R (0x08 | PL2_R) | |
1209 | #define PL1_W (0x04 | PL2_W) | |
1210 | #define PL0_R (0x02 | PL1_R) | |
1211 | #define PL0_W (0x01 | PL1_W) | |
1212 | ||
1213 | #define PL3_RW (PL3_R | PL3_W) | |
1214 | #define PL2_RW (PL2_R | PL2_W) | |
1215 | #define PL1_RW (PL1_R | PL1_W) | |
1216 | #define PL0_RW (PL0_R | PL0_W) | |
1217 | ||
dcbff19b GB |
1218 | /* Return the current Exception Level (as per ARMv8; note that this differs |
1219 | * from the ARMv7 Privilege Level). | |
1220 | */ | |
1221 | static inline int arm_current_el(CPUARMState *env) | |
4b6a83fb | 1222 | { |
6d54ed3c PM |
1223 | if (arm_feature(env, ARM_FEATURE_M)) { |
1224 | return !((env->v7m.exception == 0) && (env->v7m.control & 1)); | |
1225 | } | |
1226 | ||
592125f8 | 1227 | if (is_a64(env)) { |
f5a0a5a5 PM |
1228 | return extract32(env->pstate, 2, 2); |
1229 | } | |
1230 | ||
592125f8 FA |
1231 | switch (env->uncached_cpsr & 0x1f) { |
1232 | case ARM_CPU_MODE_USR: | |
4b6a83fb | 1233 | return 0; |
592125f8 FA |
1234 | case ARM_CPU_MODE_HYP: |
1235 | return 2; | |
1236 | case ARM_CPU_MODE_MON: | |
1237 | return 3; | |
1238 | default: | |
1239 | if (arm_is_secure(env) && !arm_el_is_aa64(env, 3)) { | |
1240 | /* If EL3 is 32-bit then all secure privileged modes run in | |
1241 | * EL3 | |
1242 | */ | |
1243 | return 3; | |
1244 | } | |
1245 | ||
1246 | return 1; | |
4b6a83fb | 1247 | } |
4b6a83fb PM |
1248 | } |
1249 | ||
1250 | typedef struct ARMCPRegInfo ARMCPRegInfo; | |
1251 | ||
f59df3f2 PM |
1252 | typedef enum CPAccessResult { |
1253 | /* Access is permitted */ | |
1254 | CP_ACCESS_OK = 0, | |
1255 | /* Access fails due to a configurable trap or enable which would | |
1256 | * result in a categorized exception syndrome giving information about | |
1257 | * the failing instruction (ie syndrome category 0x3, 0x4, 0x5, 0x6, | |
1258 | * 0xc or 0x18). | |
1259 | */ | |
1260 | CP_ACCESS_TRAP = 1, | |
1261 | /* Access fails and results in an exception syndrome 0x0 ("uncategorized"). | |
1262 | * Note that this is not a catch-all case -- the set of cases which may | |
1263 | * result in this failure is specifically defined by the architecture. | |
1264 | */ | |
1265 | CP_ACCESS_TRAP_UNCATEGORIZED = 2, | |
1266 | } CPAccessResult; | |
1267 | ||
c4241c7d PM |
1268 | /* Access functions for coprocessor registers. These cannot fail and |
1269 | * may not raise exceptions. | |
1270 | */ | |
1271 | typedef uint64_t CPReadFn(CPUARMState *env, const ARMCPRegInfo *opaque); | |
1272 | typedef void CPWriteFn(CPUARMState *env, const ARMCPRegInfo *opaque, | |
1273 | uint64_t value); | |
f59df3f2 PM |
1274 | /* Access permission check functions for coprocessor registers. */ |
1275 | typedef CPAccessResult CPAccessFn(CPUARMState *env, const ARMCPRegInfo *opaque); | |
4b6a83fb PM |
1276 | /* Hook function for register reset */ |
1277 | typedef void CPResetFn(CPUARMState *env, const ARMCPRegInfo *opaque); | |
1278 | ||
1279 | #define CP_ANY 0xff | |
1280 | ||
1281 | /* Definition of an ARM coprocessor register */ | |
1282 | struct ARMCPRegInfo { | |
1283 | /* Name of register (useful mainly for debugging, need not be unique) */ | |
1284 | const char *name; | |
1285 | /* Location of register: coprocessor number and (crn,crm,opc1,opc2) | |
1286 | * tuple. Any of crm, opc1 and opc2 may be CP_ANY to indicate a | |
1287 | * 'wildcard' field -- any value of that field in the MRC/MCR insn | |
1288 | * will be decoded to this register. The register read and write | |
1289 | * callbacks will be passed an ARMCPRegInfo with the crn/crm/opc1/opc2 | |
1290 | * used by the program, so it is possible to register a wildcard and | |
1291 | * then behave differently on read/write if necessary. | |
1292 | * For 64 bit registers, only crm and opc1 are relevant; crn and opc2 | |
1293 | * must both be zero. | |
f5a0a5a5 PM |
1294 | * For AArch64-visible registers, opc0 is also used. |
1295 | * Since there are no "coprocessors" in AArch64, cp is purely used as a | |
1296 | * way to distinguish (for KVM's benefit) guest-visible system registers | |
1297 | * from demuxed ones provided to preserve the "no side effects on | |
1298 | * KVM register read/write from QEMU" semantics. cp==0x13 is guest | |
1299 | * visible (to match KVM's encoding); cp==0 will be converted to | |
1300 | * cp==0x13 when the ARMCPRegInfo is registered, for convenience. | |
4b6a83fb PM |
1301 | */ |
1302 | uint8_t cp; | |
1303 | uint8_t crn; | |
1304 | uint8_t crm; | |
f5a0a5a5 | 1305 | uint8_t opc0; |
4b6a83fb PM |
1306 | uint8_t opc1; |
1307 | uint8_t opc2; | |
f5a0a5a5 PM |
1308 | /* Execution state in which this register is visible: ARM_CP_STATE_* */ |
1309 | int state; | |
4b6a83fb PM |
1310 | /* Register type: ARM_CP_* bits/values */ |
1311 | int type; | |
1312 | /* Access rights: PL*_[RW] */ | |
1313 | int access; | |
c3e30260 FA |
1314 | /* Security state: ARM_CP_SECSTATE_* bits/values */ |
1315 | int secure; | |
4b6a83fb PM |
1316 | /* The opaque pointer passed to define_arm_cp_regs_with_opaque() when |
1317 | * this register was defined: can be used to hand data through to the | |
1318 | * register read/write functions, since they are passed the ARMCPRegInfo*. | |
1319 | */ | |
1320 | void *opaque; | |
1321 | /* Value of this register, if it is ARM_CP_CONST. Otherwise, if | |
1322 | * fieldoffset is non-zero, the reset value of the register. | |
1323 | */ | |
1324 | uint64_t resetvalue; | |
c3e30260 FA |
1325 | /* Offset of the field in CPUARMState for this register. |
1326 | * | |
1327 | * This is not needed if either: | |
4b6a83fb PM |
1328 | * 1. type is ARM_CP_CONST or one of the ARM_CP_SPECIALs |
1329 | * 2. both readfn and writefn are specified | |
1330 | */ | |
1331 | ptrdiff_t fieldoffset; /* offsetof(CPUARMState, field) */ | |
c3e30260 FA |
1332 | |
1333 | /* Offsets of the secure and non-secure fields in CPUARMState for the | |
1334 | * register if it is banked. These fields are only used during the static | |
1335 | * registration of a register. During hashing the bank associated | |
1336 | * with a given security state is copied to fieldoffset which is used from | |
1337 | * there on out. | |
1338 | * | |
1339 | * It is expected that register definitions use either fieldoffset or | |
1340 | * bank_fieldoffsets in the definition but not both. It is also expected | |
1341 | * that both bank offsets are set when defining a banked register. This | |
1342 | * use indicates that a register is banked. | |
1343 | */ | |
1344 | ptrdiff_t bank_fieldoffsets[2]; | |
1345 | ||
f59df3f2 PM |
1346 | /* Function for making any access checks for this register in addition to |
1347 | * those specified by the 'access' permissions bits. If NULL, no extra | |
1348 | * checks required. The access check is performed at runtime, not at | |
1349 | * translate time. | |
1350 | */ | |
1351 | CPAccessFn *accessfn; | |
4b6a83fb PM |
1352 | /* Function for handling reads of this register. If NULL, then reads |
1353 | * will be done by loading from the offset into CPUARMState specified | |
1354 | * by fieldoffset. | |
1355 | */ | |
1356 | CPReadFn *readfn; | |
1357 | /* Function for handling writes of this register. If NULL, then writes | |
1358 | * will be done by writing to the offset into CPUARMState specified | |
1359 | * by fieldoffset. | |
1360 | */ | |
1361 | CPWriteFn *writefn; | |
7023ec7e PM |
1362 | /* Function for doing a "raw" read; used when we need to copy |
1363 | * coprocessor state to the kernel for KVM or out for | |
1364 | * migration. This only needs to be provided if there is also a | |
c4241c7d | 1365 | * readfn and it has side effects (for instance clear-on-read bits). |
7023ec7e PM |
1366 | */ |
1367 | CPReadFn *raw_readfn; | |
1368 | /* Function for doing a "raw" write; used when we need to copy KVM | |
1369 | * kernel coprocessor state into userspace, or for inbound | |
1370 | * migration. This only needs to be provided if there is also a | |
c4241c7d PM |
1371 | * writefn and it masks out "unwritable" bits or has write-one-to-clear |
1372 | * or similar behaviour. | |
7023ec7e PM |
1373 | */ |
1374 | CPWriteFn *raw_writefn; | |
4b6a83fb PM |
1375 | /* Function for resetting the register. If NULL, then reset will be done |
1376 | * by writing resetvalue to the field specified in fieldoffset. If | |
1377 | * fieldoffset is 0 then no reset will be done. | |
1378 | */ | |
1379 | CPResetFn *resetfn; | |
1380 | }; | |
1381 | ||
1382 | /* Macros which are lvalues for the field in CPUARMState for the | |
1383 | * ARMCPRegInfo *ri. | |
1384 | */ | |
1385 | #define CPREG_FIELD32(env, ri) \ | |
1386 | (*(uint32_t *)((char *)(env) + (ri)->fieldoffset)) | |
1387 | #define CPREG_FIELD64(env, ri) \ | |
1388 | (*(uint64_t *)((char *)(env) + (ri)->fieldoffset)) | |
1389 | ||
1390 | #define REGINFO_SENTINEL { .type = ARM_CP_SENTINEL } | |
1391 | ||
1392 | void define_arm_cp_regs_with_opaque(ARMCPU *cpu, | |
1393 | const ARMCPRegInfo *regs, void *opaque); | |
1394 | void define_one_arm_cp_reg_with_opaque(ARMCPU *cpu, | |
1395 | const ARMCPRegInfo *regs, void *opaque); | |
1396 | static inline void define_arm_cp_regs(ARMCPU *cpu, const ARMCPRegInfo *regs) | |
1397 | { | |
1398 | define_arm_cp_regs_with_opaque(cpu, regs, 0); | |
1399 | } | |
1400 | static inline void define_one_arm_cp_reg(ARMCPU *cpu, const ARMCPRegInfo *regs) | |
1401 | { | |
1402 | define_one_arm_cp_reg_with_opaque(cpu, regs, 0); | |
1403 | } | |
60322b39 | 1404 | const ARMCPRegInfo *get_arm_cp_reginfo(GHashTable *cpregs, uint32_t encoded_cp); |
4b6a83fb PM |
1405 | |
1406 | /* CPWriteFn that can be used to implement writes-ignored behaviour */ | |
c4241c7d PM |
1407 | void arm_cp_write_ignore(CPUARMState *env, const ARMCPRegInfo *ri, |
1408 | uint64_t value); | |
4b6a83fb | 1409 | /* CPReadFn that can be used for read-as-zero behaviour */ |
c4241c7d | 1410 | uint64_t arm_cp_read_zero(CPUARMState *env, const ARMCPRegInfo *ri); |
4b6a83fb | 1411 | |
f5a0a5a5 PM |
1412 | /* CPResetFn that does nothing, for use if no reset is required even |
1413 | * if fieldoffset is non zero. | |
1414 | */ | |
1415 | void arm_cp_reset_ignore(CPUARMState *env, const ARMCPRegInfo *opaque); | |
1416 | ||
67ed771d PM |
1417 | /* Return true if this reginfo struct's field in the cpu state struct |
1418 | * is 64 bits wide. | |
1419 | */ | |
1420 | static inline bool cpreg_field_is_64bit(const ARMCPRegInfo *ri) | |
1421 | { | |
1422 | return (ri->state == ARM_CP_STATE_AA64) || (ri->type & ARM_CP_64BIT); | |
1423 | } | |
1424 | ||
dcbff19b | 1425 | static inline bool cp_access_ok(int current_el, |
4b6a83fb PM |
1426 | const ARMCPRegInfo *ri, int isread) |
1427 | { | |
dcbff19b | 1428 | return (ri->access >> ((current_el * 2) + isread)) & 1; |
4b6a83fb PM |
1429 | } |
1430 | ||
721fae12 PM |
1431 | /** |
1432 | * write_list_to_cpustate | |
1433 | * @cpu: ARMCPU | |
1434 | * | |
1435 | * For each register listed in the ARMCPU cpreg_indexes list, write | |
1436 | * its value from the cpreg_values list into the ARMCPUState structure. | |
1437 | * This updates TCG's working data structures from KVM data or | |
1438 | * from incoming migration state. | |
1439 | * | |
1440 | * Returns: true if all register values were updated correctly, | |
1441 | * false if some register was unknown or could not be written. | |
1442 | * Note that we do not stop early on failure -- we will attempt | |
1443 | * writing all registers in the list. | |
1444 | */ | |
1445 | bool write_list_to_cpustate(ARMCPU *cpu); | |
1446 | ||
1447 | /** | |
1448 | * write_cpustate_to_list: | |
1449 | * @cpu: ARMCPU | |
1450 | * | |
1451 | * For each register listed in the ARMCPU cpreg_indexes list, write | |
1452 | * its value from the ARMCPUState structure into the cpreg_values list. | |
1453 | * This is used to copy info from TCG's working data structures into | |
1454 | * KVM or for outbound migration. | |
1455 | * | |
1456 | * Returns: true if all register values were read correctly, | |
1457 | * false if some register was unknown or could not be read. | |
1458 | * Note that we do not stop early on failure -- we will attempt | |
1459 | * reading all registers in the list. | |
1460 | */ | |
1461 | bool write_cpustate_to_list(ARMCPU *cpu); | |
1462 | ||
9ee6e8bb PB |
1463 | /* Does the core conform to the the "MicroController" profile. e.g. Cortex-M3. |
1464 | Note the M in older cores (eg. ARM7TDMI) stands for Multiply. These are | |
1465 | conventional cores (ie. Application or Realtime profile). */ | |
1466 | ||
1467 | #define IS_M(env) arm_feature(env, ARM_FEATURE_M) | |
9ee6e8bb | 1468 | |
9ee6e8bb PB |
1469 | #define ARM_CPUID_TI915T 0x54029152 |
1470 | #define ARM_CPUID_TI925T 0x54029252 | |
40f137e1 | 1471 | |
b5ff1b31 | 1472 | #if defined(CONFIG_USER_ONLY) |
2c0262af | 1473 | #define TARGET_PAGE_BITS 12 |
b5ff1b31 FB |
1474 | #else |
1475 | /* The ARM MMU allows 1k pages. */ | |
1476 | /* ??? Linux doesn't actually use these, and they're deprecated in recent | |
82d17978 | 1477 | architecture revisions. Maybe a configure option to disable them. */ |
b5ff1b31 FB |
1478 | #define TARGET_PAGE_BITS 10 |
1479 | #endif | |
9467d44c | 1480 | |
3926cc84 AG |
1481 | #if defined(TARGET_AARCH64) |
1482 | # define TARGET_PHYS_ADDR_SPACE_BITS 48 | |
1483 | # define TARGET_VIRT_ADDR_SPACE_BITS 64 | |
1484 | #else | |
1485 | # define TARGET_PHYS_ADDR_SPACE_BITS 40 | |
1486 | # define TARGET_VIRT_ADDR_SPACE_BITS 32 | |
1487 | #endif | |
52705890 | 1488 | |
043b7f8d EI |
1489 | static inline bool arm_excp_unmasked(CPUState *cs, unsigned int excp_idx) |
1490 | { | |
1491 | CPUARMState *env = cs->env_ptr; | |
dcbff19b | 1492 | unsigned int cur_el = arm_current_el(env); |
dfafd090 | 1493 | unsigned int target_el = arm_excp_target_el(cs, excp_idx); |
57e3a0c7 GB |
1494 | bool secure = arm_is_secure(env); |
1495 | uint32_t scr; | |
1496 | uint32_t hcr; | |
1497 | bool pstate_unmasked; | |
1498 | int8_t unmasked = 0; | |
1499 | ||
1500 | /* Don't take exceptions if they target a lower EL. | |
1501 | * This check should catch any exceptions that would not be taken but left | |
1502 | * pending. | |
1503 | */ | |
dfafd090 EI |
1504 | if (cur_el > target_el) { |
1505 | return false; | |
1506 | } | |
043b7f8d EI |
1507 | |
1508 | switch (excp_idx) { | |
1509 | case EXCP_FIQ: | |
57e3a0c7 GB |
1510 | /* If FIQs are routed to EL3 or EL2 then there are cases where we |
1511 | * override the CPSR.F in determining if the exception is masked or | |
1512 | * not. If neither of these are set then we fall back to the CPSR.F | |
1513 | * setting otherwise we further assess the state below. | |
1514 | */ | |
1515 | hcr = (env->cp15.hcr_el2 & HCR_FMO); | |
1516 | scr = (env->cp15.scr_el3 & SCR_FIQ); | |
1517 | ||
1518 | /* When EL3 is 32-bit, the SCR.FW bit controls whether the CPSR.F bit | |
1519 | * masks FIQ interrupts when taken in non-secure state. If SCR.FW is | |
1520 | * set then FIQs can be masked by CPSR.F when non-secure but only | |
1521 | * when FIQs are only routed to EL3. | |
1522 | */ | |
1523 | scr &= !((env->cp15.scr_el3 & SCR_FW) && !hcr); | |
1524 | pstate_unmasked = !(env->daif & PSTATE_F); | |
1525 | break; | |
1526 | ||
043b7f8d | 1527 | case EXCP_IRQ: |
57e3a0c7 GB |
1528 | /* When EL3 execution state is 32-bit, if HCR.IMO is set then we may |
1529 | * override the CPSR.I masking when in non-secure state. The SCR.IRQ | |
1530 | * setting has already been taken into consideration when setting the | |
1531 | * target EL, so it does not have a further affect here. | |
1532 | */ | |
1533 | hcr = (env->cp15.hcr_el2 & HCR_IMO); | |
1534 | scr = false; | |
1535 | pstate_unmasked = !(env->daif & PSTATE_I); | |
1536 | break; | |
1537 | ||
136e67e9 | 1538 | case EXCP_VFIQ: |
9fae24f5 | 1539 | if (secure || !(env->cp15.hcr_el2 & HCR_FMO)) { |
136e67e9 EI |
1540 | /* VFIQs are only taken when hypervized and non-secure. */ |
1541 | return false; | |
1542 | } | |
1543 | return !(env->daif & PSTATE_F); | |
1544 | case EXCP_VIRQ: | |
9fae24f5 | 1545 | if (secure || !(env->cp15.hcr_el2 & HCR_IMO)) { |
136e67e9 EI |
1546 | /* VIRQs are only taken when hypervized and non-secure. */ |
1547 | return false; | |
1548 | } | |
b5c633c5 | 1549 | return !(env->daif & PSTATE_I); |
043b7f8d EI |
1550 | default: |
1551 | g_assert_not_reached(); | |
1552 | } | |
57e3a0c7 GB |
1553 | |
1554 | /* Use the target EL, current execution state and SCR/HCR settings to | |
1555 | * determine whether the corresponding CPSR bit is used to mask the | |
1556 | * interrupt. | |
1557 | */ | |
1558 | if ((target_el > cur_el) && (target_el != 1)) { | |
1559 | if (arm_el_is_aa64(env, 3) || ((scr || hcr) && (!secure))) { | |
1560 | unmasked = 1; | |
1561 | } | |
1562 | } | |
1563 | ||
1564 | /* The PSTATE bits only mask the interrupt if we have not overriden the | |
1565 | * ability above. | |
1566 | */ | |
1567 | return unmasked || pstate_unmasked; | |
043b7f8d EI |
1568 | } |
1569 | ||
ad37ad5b PM |
1570 | static inline CPUARMState *cpu_init(const char *cpu_model) |
1571 | { | |
1572 | ARMCPU *cpu = cpu_arm_init(cpu_model); | |
1573 | if (cpu) { | |
1574 | return &cpu->env; | |
1575 | } | |
1576 | return NULL; | |
1577 | } | |
1578 | ||
9467d44c TS |
1579 | #define cpu_exec cpu_arm_exec |
1580 | #define cpu_gen_code cpu_arm_gen_code | |
1581 | #define cpu_signal_handler cpu_arm_signal_handler | |
c732abe2 | 1582 | #define cpu_list arm_cpu_list |
9467d44c | 1583 | |
c1e37810 PM |
1584 | /* ARM has the following "translation regimes" (as the ARM ARM calls them): |
1585 | * | |
1586 | * If EL3 is 64-bit: | |
1587 | * + NonSecure EL1 & 0 stage 1 | |
1588 | * + NonSecure EL1 & 0 stage 2 | |
1589 | * + NonSecure EL2 | |
1590 | * + Secure EL1 & EL0 | |
1591 | * + Secure EL3 | |
1592 | * If EL3 is 32-bit: | |
1593 | * + NonSecure PL1 & 0 stage 1 | |
1594 | * + NonSecure PL1 & 0 stage 2 | |
1595 | * + NonSecure PL2 | |
1596 | * + Secure PL0 & PL1 | |
1597 | * (reminder: for 32 bit EL3, Secure PL1 is *EL3*, not EL1.) | |
1598 | * | |
1599 | * For QEMU, an mmu_idx is not quite the same as a translation regime because: | |
1600 | * 1. we need to split the "EL1 & 0" regimes into two mmu_idxes, because they | |
1601 | * may differ in access permissions even if the VA->PA map is the same | |
1602 | * 2. we want to cache in our TLB the full VA->IPA->PA lookup for a stage 1+2 | |
1603 | * translation, which means that we have one mmu_idx that deals with two | |
1604 | * concatenated translation regimes [this sort of combined s1+2 TLB is | |
1605 | * architecturally permitted] | |
1606 | * 3. we don't need to allocate an mmu_idx to translations that we won't be | |
1607 | * handling via the TLB. The only way to do a stage 1 translation without | |
1608 | * the immediate stage 2 translation is via the ATS or AT system insns, | |
1609 | * which can be slow-pathed and always do a page table walk. | |
1610 | * 4. we can also safely fold together the "32 bit EL3" and "64 bit EL3" | |
1611 | * translation regimes, because they map reasonably well to each other | |
1612 | * and they can't both be active at the same time. | |
1613 | * This gives us the following list of mmu_idx values: | |
1614 | * | |
1615 | * NS EL0 (aka NS PL0) stage 1+2 | |
1616 | * NS EL1 (aka NS PL1) stage 1+2 | |
1617 | * NS EL2 (aka NS PL2) | |
1618 | * S EL3 (aka S PL1) | |
1619 | * S EL0 (aka S PL0) | |
1620 | * S EL1 (not used if EL3 is 32 bit) | |
1621 | * NS EL0+1 stage 2 | |
1622 | * | |
1623 | * (The last of these is an mmu_idx because we want to be able to use the TLB | |
1624 | * for the accesses done as part of a stage 1 page table walk, rather than | |
1625 | * having to walk the stage 2 page table over and over.) | |
1626 | * | |
1627 | * Our enumeration includes at the end some entries which are not "true" | |
1628 | * mmu_idx values in that they don't have corresponding TLBs and are only | |
1629 | * valid for doing slow path page table walks. | |
1630 | * | |
1631 | * The constant names here are patterned after the general style of the names | |
1632 | * of the AT/ATS operations. | |
1633 | * The values used are carefully arranged to make mmu_idx => EL lookup easy. | |
1634 | */ | |
1635 | typedef enum ARMMMUIdx { | |
1636 | ARMMMUIdx_S12NSE0 = 0, | |
1637 | ARMMMUIdx_S12NSE1 = 1, | |
1638 | ARMMMUIdx_S1E2 = 2, | |
1639 | ARMMMUIdx_S1E3 = 3, | |
1640 | ARMMMUIdx_S1SE0 = 4, | |
1641 | ARMMMUIdx_S1SE1 = 5, | |
1642 | ARMMMUIdx_S2NS = 6, | |
1643 | /* Indexes below here don't have TLBs and are used only for AT system | |
1644 | * instructions or for the first stage of an S12 page table walk. | |
1645 | */ | |
1646 | ARMMMUIdx_S1NSE0 = 7, | |
1647 | ARMMMUIdx_S1NSE1 = 8, | |
1648 | } ARMMMUIdx; | |
1649 | ||
f79fbf39 | 1650 | #define MMU_USER_IDX 0 |
c1e37810 PM |
1651 | |
1652 | /* Return the exception level we're running at if this is our mmu_idx */ | |
1653 | static inline int arm_mmu_idx_to_el(ARMMMUIdx mmu_idx) | |
6ebbf390 | 1654 | { |
c1e37810 PM |
1655 | assert(mmu_idx < ARMMMUIdx_S2NS); |
1656 | return mmu_idx & 3; | |
1657 | } | |
1658 | ||
1659 | /* Determine the current mmu_idx to use for normal loads/stores */ | |
1660 | static inline int cpu_mmu_index(CPUARMState *env) | |
1661 | { | |
1662 | int el = arm_current_el(env); | |
1663 | ||
1664 | if (el < 2 && arm_is_secure_below_el3(env)) { | |
1665 | return ARMMMUIdx_S1SE0 + el; | |
1666 | } | |
1667 | return el; | |
6ebbf390 JM |
1668 | } |
1669 | ||
3a298203 PM |
1670 | /* Return the Exception Level targeted by debug exceptions; |
1671 | * currently always EL1 since we don't implement EL2 or EL3. | |
1672 | */ | |
1673 | static inline int arm_debug_target_el(CPUARMState *env) | |
1674 | { | |
1675 | return 1; | |
1676 | } | |
1677 | ||
1678 | static inline bool aa64_generate_debug_exceptions(CPUARMState *env) | |
1679 | { | |
dcbff19b | 1680 | if (arm_current_el(env) == arm_debug_target_el(env)) { |
3a298203 PM |
1681 | if ((extract32(env->cp15.mdscr_el1, 13, 1) == 0) |
1682 | || (env->daif & PSTATE_D)) { | |
1683 | return false; | |
1684 | } | |
1685 | } | |
1686 | return true; | |
1687 | } | |
1688 | ||
1689 | static inline bool aa32_generate_debug_exceptions(CPUARMState *env) | |
1690 | { | |
dcbff19b | 1691 | if (arm_current_el(env) == 0 && arm_el_is_aa64(env, 1)) { |
3a298203 PM |
1692 | return aa64_generate_debug_exceptions(env); |
1693 | } | |
dcbff19b | 1694 | return arm_current_el(env) != 2; |
3a298203 PM |
1695 | } |
1696 | ||
1697 | /* Return true if debugging exceptions are currently enabled. | |
1698 | * This corresponds to what in ARM ARM pseudocode would be | |
1699 | * if UsingAArch32() then | |
1700 | * return AArch32.GenerateDebugExceptions() | |
1701 | * else | |
1702 | * return AArch64.GenerateDebugExceptions() | |
1703 | * We choose to push the if() down into this function for clarity, | |
1704 | * since the pseudocode has it at all callsites except for the one in | |
1705 | * CheckSoftwareStep(), where it is elided because both branches would | |
1706 | * always return the same value. | |
1707 | * | |
1708 | * Parts of the pseudocode relating to EL2 and EL3 are omitted because we | |
1709 | * don't yet implement those exception levels or their associated trap bits. | |
1710 | */ | |
1711 | static inline bool arm_generate_debug_exceptions(CPUARMState *env) | |
1712 | { | |
1713 | if (env->aarch64) { | |
1714 | return aa64_generate_debug_exceptions(env); | |
1715 | } else { | |
1716 | return aa32_generate_debug_exceptions(env); | |
1717 | } | |
1718 | } | |
1719 | ||
1720 | /* Is single-stepping active? (Note that the "is EL_D AArch64?" check | |
1721 | * implicitly means this always returns false in pre-v8 CPUs.) | |
1722 | */ | |
1723 | static inline bool arm_singlestep_active(CPUARMState *env) | |
1724 | { | |
1725 | return extract32(env->cp15.mdscr_el1, 0, 1) | |
1726 | && arm_el_is_aa64(env, arm_debug_target_el(env)) | |
1727 | && arm_generate_debug_exceptions(env); | |
1728 | } | |
1729 | ||
022c62cb | 1730 | #include "exec/cpu-all.h" |
622ed360 | 1731 | |
3926cc84 AG |
1732 | /* Bit usage in the TB flags field: bit 31 indicates whether we are |
1733 | * in 32 or 64 bit mode. The meaning of the other bits depends on that. | |
c1e37810 PM |
1734 | * We put flags which are shared between 32 and 64 bit mode at the top |
1735 | * of the word, and flags which apply to only one mode at the bottom. | |
3926cc84 AG |
1736 | */ |
1737 | #define ARM_TBFLAG_AARCH64_STATE_SHIFT 31 | |
1738 | #define ARM_TBFLAG_AARCH64_STATE_MASK (1U << ARM_TBFLAG_AARCH64_STATE_SHIFT) | |
c1e37810 PM |
1739 | #define ARM_TBFLAG_MMUIDX_SHIFT 28 |
1740 | #define ARM_TBFLAG_MMUIDX_MASK (0x7 << ARM_TBFLAG_MMUIDX_SHIFT) | |
3926cc84 AG |
1741 | |
1742 | /* Bit usage when in AArch32 state: */ | |
a1705768 PM |
1743 | #define ARM_TBFLAG_THUMB_SHIFT 0 |
1744 | #define ARM_TBFLAG_THUMB_MASK (1 << ARM_TBFLAG_THUMB_SHIFT) | |
1745 | #define ARM_TBFLAG_VECLEN_SHIFT 1 | |
1746 | #define ARM_TBFLAG_VECLEN_MASK (0x7 << ARM_TBFLAG_VECLEN_SHIFT) | |
1747 | #define ARM_TBFLAG_VECSTRIDE_SHIFT 4 | |
1748 | #define ARM_TBFLAG_VECSTRIDE_MASK (0x3 << ARM_TBFLAG_VECSTRIDE_SHIFT) | |
a1705768 PM |
1749 | #define ARM_TBFLAG_VFPEN_SHIFT 7 |
1750 | #define ARM_TBFLAG_VFPEN_MASK (1 << ARM_TBFLAG_VFPEN_SHIFT) | |
1751 | #define ARM_TBFLAG_CONDEXEC_SHIFT 8 | |
1752 | #define ARM_TBFLAG_CONDEXEC_MASK (0xff << ARM_TBFLAG_CONDEXEC_SHIFT) | |
d8fd2954 PB |
1753 | #define ARM_TBFLAG_BSWAP_CODE_SHIFT 16 |
1754 | #define ARM_TBFLAG_BSWAP_CODE_MASK (1 << ARM_TBFLAG_BSWAP_CODE_SHIFT) | |
2c7ffc41 PM |
1755 | #define ARM_TBFLAG_CPACR_FPEN_SHIFT 17 |
1756 | #define ARM_TBFLAG_CPACR_FPEN_MASK (1 << ARM_TBFLAG_CPACR_FPEN_SHIFT) | |
50225ad0 PM |
1757 | #define ARM_TBFLAG_SS_ACTIVE_SHIFT 18 |
1758 | #define ARM_TBFLAG_SS_ACTIVE_MASK (1 << ARM_TBFLAG_SS_ACTIVE_SHIFT) | |
1759 | #define ARM_TBFLAG_PSTATE_SS_SHIFT 19 | |
1760 | #define ARM_TBFLAG_PSTATE_SS_MASK (1 << ARM_TBFLAG_PSTATE_SS_SHIFT) | |
c0f4af17 PM |
1761 | /* We store the bottom two bits of the CPAR as TB flags and handle |
1762 | * checks on the other bits at runtime | |
1763 | */ | |
1764 | #define ARM_TBFLAG_XSCALE_CPAR_SHIFT 20 | |
1765 | #define ARM_TBFLAG_XSCALE_CPAR_MASK (3 << ARM_TBFLAG_XSCALE_CPAR_SHIFT) | |
3f342b9e SF |
1766 | /* Indicates whether cp register reads and writes by guest code should access |
1767 | * the secure or nonsecure bank of banked registers; note that this is not | |
1768 | * the same thing as the current security state of the processor! | |
1769 | */ | |
1770 | #define ARM_TBFLAG_NS_SHIFT 22 | |
1771 | #define ARM_TBFLAG_NS_MASK (1 << ARM_TBFLAG_NS_SHIFT) | |
3926cc84 | 1772 | |
d9ea7d29 | 1773 | /* Bit usage when in AArch64 state */ |
8c6afa6a PM |
1774 | #define ARM_TBFLAG_AA64_FPEN_SHIFT 2 |
1775 | #define ARM_TBFLAG_AA64_FPEN_MASK (1 << ARM_TBFLAG_AA64_FPEN_SHIFT) | |
7ea47fe7 PM |
1776 | #define ARM_TBFLAG_AA64_SS_ACTIVE_SHIFT 3 |
1777 | #define ARM_TBFLAG_AA64_SS_ACTIVE_MASK (1 << ARM_TBFLAG_AA64_SS_ACTIVE_SHIFT) | |
1778 | #define ARM_TBFLAG_AA64_PSTATE_SS_SHIFT 4 | |
1779 | #define ARM_TBFLAG_AA64_PSTATE_SS_MASK (1 << ARM_TBFLAG_AA64_PSTATE_SS_SHIFT) | |
a1705768 PM |
1780 | |
1781 | /* some convenience accessor macros */ | |
3926cc84 AG |
1782 | #define ARM_TBFLAG_AARCH64_STATE(F) \ |
1783 | (((F) & ARM_TBFLAG_AARCH64_STATE_MASK) >> ARM_TBFLAG_AARCH64_STATE_SHIFT) | |
c1e37810 PM |
1784 | #define ARM_TBFLAG_MMUIDX(F) \ |
1785 | (((F) & ARM_TBFLAG_MMUIDX_MASK) >> ARM_TBFLAG_MMUIDX_SHIFT) | |
a1705768 PM |
1786 | #define ARM_TBFLAG_THUMB(F) \ |
1787 | (((F) & ARM_TBFLAG_THUMB_MASK) >> ARM_TBFLAG_THUMB_SHIFT) | |
1788 | #define ARM_TBFLAG_VECLEN(F) \ | |
1789 | (((F) & ARM_TBFLAG_VECLEN_MASK) >> ARM_TBFLAG_VECLEN_SHIFT) | |
1790 | #define ARM_TBFLAG_VECSTRIDE(F) \ | |
1791 | (((F) & ARM_TBFLAG_VECSTRIDE_MASK) >> ARM_TBFLAG_VECSTRIDE_SHIFT) | |
a1705768 PM |
1792 | #define ARM_TBFLAG_VFPEN(F) \ |
1793 | (((F) & ARM_TBFLAG_VFPEN_MASK) >> ARM_TBFLAG_VFPEN_SHIFT) | |
1794 | #define ARM_TBFLAG_CONDEXEC(F) \ | |
1795 | (((F) & ARM_TBFLAG_CONDEXEC_MASK) >> ARM_TBFLAG_CONDEXEC_SHIFT) | |
d8fd2954 PB |
1796 | #define ARM_TBFLAG_BSWAP_CODE(F) \ |
1797 | (((F) & ARM_TBFLAG_BSWAP_CODE_MASK) >> ARM_TBFLAG_BSWAP_CODE_SHIFT) | |
2c7ffc41 PM |
1798 | #define ARM_TBFLAG_CPACR_FPEN(F) \ |
1799 | (((F) & ARM_TBFLAG_CPACR_FPEN_MASK) >> ARM_TBFLAG_CPACR_FPEN_SHIFT) | |
50225ad0 PM |
1800 | #define ARM_TBFLAG_SS_ACTIVE(F) \ |
1801 | (((F) & ARM_TBFLAG_SS_ACTIVE_MASK) >> ARM_TBFLAG_SS_ACTIVE_SHIFT) | |
1802 | #define ARM_TBFLAG_PSTATE_SS(F) \ | |
1803 | (((F) & ARM_TBFLAG_PSTATE_SS_MASK) >> ARM_TBFLAG_PSTATE_SS_SHIFT) | |
c0f4af17 PM |
1804 | #define ARM_TBFLAG_XSCALE_CPAR(F) \ |
1805 | (((F) & ARM_TBFLAG_XSCALE_CPAR_MASK) >> ARM_TBFLAG_XSCALE_CPAR_SHIFT) | |
8c6afa6a PM |
1806 | #define ARM_TBFLAG_AA64_FPEN(F) \ |
1807 | (((F) & ARM_TBFLAG_AA64_FPEN_MASK) >> ARM_TBFLAG_AA64_FPEN_SHIFT) | |
7ea47fe7 PM |
1808 | #define ARM_TBFLAG_AA64_SS_ACTIVE(F) \ |
1809 | (((F) & ARM_TBFLAG_AA64_SS_ACTIVE_MASK) >> ARM_TBFLAG_AA64_SS_ACTIVE_SHIFT) | |
1810 | #define ARM_TBFLAG_AA64_PSTATE_SS(F) \ | |
1811 | (((F) & ARM_TBFLAG_AA64_PSTATE_SS_MASK) >> ARM_TBFLAG_AA64_PSTATE_SS_SHIFT) | |
3f342b9e SF |
1812 | #define ARM_TBFLAG_NS(F) \ |
1813 | (((F) & ARM_TBFLAG_NS_MASK) >> ARM_TBFLAG_NS_SHIFT) | |
a1705768 | 1814 | |
0ecb72a5 | 1815 | static inline void cpu_get_tb_cpu_state(CPUARMState *env, target_ulong *pc, |
6b917547 AL |
1816 | target_ulong *cs_base, int *flags) |
1817 | { | |
ed1f13d6 PM |
1818 | int fpen; |
1819 | ||
1820 | if (arm_feature(env, ARM_FEATURE_V6)) { | |
1821 | fpen = extract32(env->cp15.c1_coproc, 20, 2); | |
1822 | } else { | |
1823 | /* CPACR doesn't exist before v6, so VFP is always accessible */ | |
1824 | fpen = 3; | |
1825 | } | |
8c6afa6a | 1826 | |
3926cc84 AG |
1827 | if (is_a64(env)) { |
1828 | *pc = env->pc; | |
c1e37810 | 1829 | *flags = ARM_TBFLAG_AARCH64_STATE_MASK; |
dcbff19b | 1830 | if (fpen == 3 || (fpen == 1 && arm_current_el(env) != 0)) { |
8c6afa6a PM |
1831 | *flags |= ARM_TBFLAG_AA64_FPEN_MASK; |
1832 | } | |
7ea47fe7 PM |
1833 | /* The SS_ACTIVE and PSTATE_SS bits correspond to the state machine |
1834 | * states defined in the ARM ARM for software singlestep: | |
1835 | * SS_ACTIVE PSTATE.SS State | |
1836 | * 0 x Inactive (the TB flag for SS is always 0) | |
1837 | * 1 0 Active-pending | |
1838 | * 1 1 Active-not-pending | |
1839 | */ | |
1840 | if (arm_singlestep_active(env)) { | |
1841 | *flags |= ARM_TBFLAG_AA64_SS_ACTIVE_MASK; | |
1842 | if (env->pstate & PSTATE_SS) { | |
1843 | *flags |= ARM_TBFLAG_AA64_PSTATE_SS_MASK; | |
1844 | } | |
1845 | } | |
05ed9a99 | 1846 | } else { |
3926cc84 AG |
1847 | *pc = env->regs[15]; |
1848 | *flags = (env->thumb << ARM_TBFLAG_THUMB_SHIFT) | |
1849 | | (env->vfp.vec_len << ARM_TBFLAG_VECLEN_SHIFT) | |
1850 | | (env->vfp.vec_stride << ARM_TBFLAG_VECSTRIDE_SHIFT) | |
1851 | | (env->condexec_bits << ARM_TBFLAG_CONDEXEC_SHIFT) | |
1852 | | (env->bswap_code << ARM_TBFLAG_BSWAP_CODE_SHIFT); | |
3f342b9e SF |
1853 | if (!(access_secure_reg(env))) { |
1854 | *flags |= ARM_TBFLAG_NS_MASK; | |
1855 | } | |
2c7ffc41 PM |
1856 | if (env->vfp.xregs[ARM_VFP_FPEXC] & (1 << 30) |
1857 | || arm_el_is_aa64(env, 1)) { | |
3926cc84 AG |
1858 | *flags |= ARM_TBFLAG_VFPEN_MASK; |
1859 | } | |
dcbff19b | 1860 | if (fpen == 3 || (fpen == 1 && arm_current_el(env) != 0)) { |
2c7ffc41 PM |
1861 | *flags |= ARM_TBFLAG_CPACR_FPEN_MASK; |
1862 | } | |
50225ad0 PM |
1863 | /* The SS_ACTIVE and PSTATE_SS bits correspond to the state machine |
1864 | * states defined in the ARM ARM for software singlestep: | |
1865 | * SS_ACTIVE PSTATE.SS State | |
1866 | * 0 x Inactive (the TB flag for SS is always 0) | |
1867 | * 1 0 Active-pending | |
1868 | * 1 1 Active-not-pending | |
1869 | */ | |
1870 | if (arm_singlestep_active(env)) { | |
1871 | *flags |= ARM_TBFLAG_SS_ACTIVE_MASK; | |
1872 | if (env->uncached_cpsr & PSTATE_SS) { | |
1873 | *flags |= ARM_TBFLAG_PSTATE_SS_MASK; | |
1874 | } | |
1875 | } | |
c0f4af17 PM |
1876 | *flags |= (extract32(env->cp15.c15_cpar, 0, 2) |
1877 | << ARM_TBFLAG_XSCALE_CPAR_SHIFT); | |
a1705768 | 1878 | } |
3926cc84 | 1879 | |
c1e37810 PM |
1880 | *flags |= (cpu_mmu_index(env) << ARM_TBFLAG_MMUIDX_SHIFT); |
1881 | ||
3926cc84 | 1882 | *cs_base = 0; |
6b917547 AL |
1883 | } |
1884 | ||
022c62cb | 1885 | #include "exec/exec-all.h" |
f081c76c | 1886 | |
3926cc84 AG |
1887 | static inline void cpu_pc_from_tb(CPUARMState *env, TranslationBlock *tb) |
1888 | { | |
1889 | if (ARM_TBFLAG_AARCH64_STATE(tb->flags)) { | |
1890 | env->pc = tb->pc; | |
1891 | } else { | |
1892 | env->regs[15] = tb->pc; | |
1893 | } | |
1894 | } | |
1895 | ||
98128601 RH |
1896 | enum { |
1897 | QEMU_PSCI_CONDUIT_DISABLED = 0, | |
1898 | QEMU_PSCI_CONDUIT_SMC = 1, | |
1899 | QEMU_PSCI_CONDUIT_HVC = 2, | |
1900 | }; | |
1901 | ||
2c0262af | 1902 | #endif |