9 #include "qemu-common.h"
10 #include "host-utils.h"
12 static uint32_t cortexa9_cp15_c0_c1
[8] =
13 { 0x1031, 0x11, 0x000, 0, 0x00100103, 0x20000000, 0x01230000, 0x00002111 };
15 static uint32_t cortexa9_cp15_c0_c2
[8] =
16 { 0x00101111, 0x13112111, 0x21232041, 0x11112131, 0x00111142, 0, 0, 0 };
18 static uint32_t cortexa8_cp15_c0_c1
[8] =
19 { 0x1031, 0x11, 0x400, 0, 0x31100003, 0x20000000, 0x01202000, 0x11 };
21 static uint32_t cortexa8_cp15_c0_c2
[8] =
22 { 0x00101111, 0x12112111, 0x21232031, 0x11112131, 0x00111142, 0, 0, 0 };
24 static uint32_t mpcore_cp15_c0_c1
[8] =
25 { 0x111, 0x1, 0, 0x2, 0x01100103, 0x10020302, 0x01222000, 0 };
27 static uint32_t mpcore_cp15_c0_c2
[8] =
28 { 0x00100011, 0x12002111, 0x11221011, 0x01102131, 0x141, 0, 0, 0 };
30 static uint32_t arm1136_cp15_c0_c1
[8] =
31 { 0x111, 0x1, 0x2, 0x3, 0x01130003, 0x10030302, 0x01222110, 0 };
33 static uint32_t arm1136_cp15_c0_c2
[8] =
34 { 0x00140011, 0x12002111, 0x11231111, 0x01102131, 0x141, 0, 0, 0 };
36 static uint32_t cpu_arm_find_by_name(const char *name
);
38 static inline void set_feature(CPUARMState
*env
, int feature
)
40 env
->features
|= 1u << feature
;
43 static void cpu_reset_model_id(CPUARMState
*env
, uint32_t id
)
45 env
->cp15
.c0_cpuid
= id
;
47 case ARM_CPUID_ARM926
:
48 set_feature(env
, ARM_FEATURE_VFP
);
49 env
->vfp
.xregs
[ARM_VFP_FPSID
] = 0x41011090;
50 env
->cp15
.c0_cachetype
= 0x1dd20d2;
51 env
->cp15
.c1_sys
= 0x00090078;
53 case ARM_CPUID_ARM946
:
54 set_feature(env
, ARM_FEATURE_MPU
);
55 env
->cp15
.c0_cachetype
= 0x0f004006;
56 env
->cp15
.c1_sys
= 0x00000078;
58 case ARM_CPUID_ARM1026
:
59 set_feature(env
, ARM_FEATURE_VFP
);
60 set_feature(env
, ARM_FEATURE_AUXCR
);
61 env
->vfp
.xregs
[ARM_VFP_FPSID
] = 0x410110a0;
62 env
->cp15
.c0_cachetype
= 0x1dd20d2;
63 env
->cp15
.c1_sys
= 0x00090078;
65 case ARM_CPUID_ARM1136_R2
:
66 case ARM_CPUID_ARM1136
:
67 set_feature(env
, ARM_FEATURE_V6
);
68 set_feature(env
, ARM_FEATURE_VFP
);
69 set_feature(env
, ARM_FEATURE_AUXCR
);
70 env
->vfp
.xregs
[ARM_VFP_FPSID
] = 0x410120b4;
71 env
->vfp
.xregs
[ARM_VFP_MVFR0
] = 0x11111111;
72 env
->vfp
.xregs
[ARM_VFP_MVFR1
] = 0x00000000;
73 memcpy(env
->cp15
.c0_c1
, arm1136_cp15_c0_c1
, 8 * sizeof(uint32_t));
74 memcpy(env
->cp15
.c0_c2
, arm1136_cp15_c0_c2
, 8 * sizeof(uint32_t));
75 env
->cp15
.c0_cachetype
= 0x1dd20d2;
77 case ARM_CPUID_ARM11MPCORE
:
78 set_feature(env
, ARM_FEATURE_V6
);
79 set_feature(env
, ARM_FEATURE_V6K
);
80 set_feature(env
, ARM_FEATURE_VFP
);
81 set_feature(env
, ARM_FEATURE_AUXCR
);
82 env
->vfp
.xregs
[ARM_VFP_FPSID
] = 0x410120b4;
83 env
->vfp
.xregs
[ARM_VFP_MVFR0
] = 0x11111111;
84 env
->vfp
.xregs
[ARM_VFP_MVFR1
] = 0x00000000;
85 memcpy(env
->cp15
.c0_c1
, mpcore_cp15_c0_c1
, 8 * sizeof(uint32_t));
86 memcpy(env
->cp15
.c0_c2
, mpcore_cp15_c0_c2
, 8 * sizeof(uint32_t));
87 env
->cp15
.c0_cachetype
= 0x1dd20d2;
89 case ARM_CPUID_CORTEXA8
:
90 set_feature(env
, ARM_FEATURE_V6
);
91 set_feature(env
, ARM_FEATURE_V6K
);
92 set_feature(env
, ARM_FEATURE_V7
);
93 set_feature(env
, ARM_FEATURE_AUXCR
);
94 set_feature(env
, ARM_FEATURE_THUMB2
);
95 set_feature(env
, ARM_FEATURE_VFP
);
96 set_feature(env
, ARM_FEATURE_VFP3
);
97 set_feature(env
, ARM_FEATURE_NEON
);
98 set_feature(env
, ARM_FEATURE_THUMB2EE
);
99 env
->vfp
.xregs
[ARM_VFP_FPSID
] = 0x410330c0;
100 env
->vfp
.xregs
[ARM_VFP_MVFR0
] = 0x11110222;
101 env
->vfp
.xregs
[ARM_VFP_MVFR1
] = 0x00011100;
102 memcpy(env
->cp15
.c0_c1
, cortexa8_cp15_c0_c1
, 8 * sizeof(uint32_t));
103 memcpy(env
->cp15
.c0_c2
, cortexa8_cp15_c0_c2
, 8 * sizeof(uint32_t));
104 env
->cp15
.c0_cachetype
= 0x82048004;
105 env
->cp15
.c0_clid
= (1 << 27) | (2 << 24) | 3;
106 env
->cp15
.c0_ccsid
[0] = 0xe007e01a; /* 16k L1 dcache. */
107 env
->cp15
.c0_ccsid
[1] = 0x2007e01a; /* 16k L1 icache. */
108 env
->cp15
.c0_ccsid
[2] = 0xf0000000; /* No L2 icache. */
110 case ARM_CPUID_CORTEXA9
:
111 set_feature(env
, ARM_FEATURE_V6
);
112 set_feature(env
, ARM_FEATURE_V6K
);
113 set_feature(env
, ARM_FEATURE_V7
);
114 set_feature(env
, ARM_FEATURE_AUXCR
);
115 set_feature(env
, ARM_FEATURE_THUMB2
);
116 set_feature(env
, ARM_FEATURE_VFP
);
117 set_feature(env
, ARM_FEATURE_VFP3
);
118 set_feature(env
, ARM_FEATURE_VFP_FP16
);
119 set_feature(env
, ARM_FEATURE_NEON
);
120 set_feature(env
, ARM_FEATURE_THUMB2EE
);
121 env
->vfp
.xregs
[ARM_VFP_FPSID
] = 0x41034000; /* Guess */
122 env
->vfp
.xregs
[ARM_VFP_MVFR0
] = 0x11110222;
123 env
->vfp
.xregs
[ARM_VFP_MVFR1
] = 0x01111111;
124 memcpy(env
->cp15
.c0_c1
, cortexa9_cp15_c0_c1
, 8 * sizeof(uint32_t));
125 memcpy(env
->cp15
.c0_c2
, cortexa9_cp15_c0_c2
, 8 * sizeof(uint32_t));
126 env
->cp15
.c0_cachetype
= 0x80038003;
127 env
->cp15
.c0_clid
= (1 << 27) | (1 << 24) | 3;
128 env
->cp15
.c0_ccsid
[0] = 0xe00fe015; /* 16k L1 dcache. */
129 env
->cp15
.c0_ccsid
[1] = 0x200fe015; /* 16k L1 icache. */
131 case ARM_CPUID_CORTEXM3
:
132 set_feature(env
, ARM_FEATURE_V6
);
133 set_feature(env
, ARM_FEATURE_THUMB2
);
134 set_feature(env
, ARM_FEATURE_V7
);
135 set_feature(env
, ARM_FEATURE_M
);
136 set_feature(env
, ARM_FEATURE_DIV
);
138 case ARM_CPUID_ANY
: /* For userspace emulation. */
139 set_feature(env
, ARM_FEATURE_V6
);
140 set_feature(env
, ARM_FEATURE_V6K
);
141 set_feature(env
, ARM_FEATURE_V7
);
142 set_feature(env
, ARM_FEATURE_THUMB2
);
143 set_feature(env
, ARM_FEATURE_VFP
);
144 set_feature(env
, ARM_FEATURE_VFP3
);
145 set_feature(env
, ARM_FEATURE_VFP_FP16
);
146 set_feature(env
, ARM_FEATURE_NEON
);
147 set_feature(env
, ARM_FEATURE_THUMB2EE
);
148 set_feature(env
, ARM_FEATURE_DIV
);
150 case ARM_CPUID_TI915T
:
151 case ARM_CPUID_TI925T
:
152 set_feature(env
, ARM_FEATURE_OMAPCP
);
153 env
->cp15
.c0_cpuid
= ARM_CPUID_TI925T
; /* Depends on wiring. */
154 env
->cp15
.c0_cachetype
= 0x5109149;
155 env
->cp15
.c1_sys
= 0x00000070;
156 env
->cp15
.c15_i_max
= 0x000;
157 env
->cp15
.c15_i_min
= 0xff0;
159 case ARM_CPUID_PXA250
:
160 case ARM_CPUID_PXA255
:
161 case ARM_CPUID_PXA260
:
162 case ARM_CPUID_PXA261
:
163 case ARM_CPUID_PXA262
:
164 set_feature(env
, ARM_FEATURE_XSCALE
);
165 /* JTAG_ID is ((id << 28) | 0x09265013) */
166 env
->cp15
.c0_cachetype
= 0xd172172;
167 env
->cp15
.c1_sys
= 0x00000078;
169 case ARM_CPUID_PXA270_A0
:
170 case ARM_CPUID_PXA270_A1
:
171 case ARM_CPUID_PXA270_B0
:
172 case ARM_CPUID_PXA270_B1
:
173 case ARM_CPUID_PXA270_C0
:
174 case ARM_CPUID_PXA270_C5
:
175 set_feature(env
, ARM_FEATURE_XSCALE
);
176 /* JTAG_ID is ((id << 28) | 0x09265013) */
177 set_feature(env
, ARM_FEATURE_IWMMXT
);
178 env
->iwmmxt
.cregs
[ARM_IWMMXT_wCID
] = 0x69051000 | 'Q';
179 env
->cp15
.c0_cachetype
= 0xd172172;
180 env
->cp15
.c1_sys
= 0x00000078;
183 cpu_abort(env
, "Bad CPU ID: %x\n", id
);
188 void cpu_reset(CPUARMState
*env
)
192 if (qemu_loglevel_mask(CPU_LOG_RESET
)) {
193 qemu_log("CPU Reset (CPU %d)\n", env
->cpu_index
);
194 log_cpu_state(env
, 0);
197 id
= env
->cp15
.c0_cpuid
;
198 memset(env
, 0, offsetof(CPUARMState
, breakpoints
));
200 cpu_reset_model_id(env
, id
);
201 #if defined (CONFIG_USER_ONLY)
202 env
->uncached_cpsr
= ARM_CPU_MODE_USR
;
203 env
->vfp
.xregs
[ARM_VFP_FPEXC
] = 1 << 30;
205 /* SVC mode with interrupts disabled. */
206 env
->uncached_cpsr
= ARM_CPU_MODE_SVC
| CPSR_A
| CPSR_F
| CPSR_I
;
207 /* On ARMv7-M the CPSR_I is the value of the PRIMASK register, and is
210 env
->uncached_cpsr
&= ~CPSR_I
;
211 env
->vfp
.xregs
[ARM_VFP_FPEXC
] = 0;
212 env
->cp15
.c2_base_mask
= 0xffffc000u
;
218 static int vfp_gdb_get_reg(CPUState
*env
, uint8_t *buf
, int reg
)
222 /* VFP data registers are always little-endian. */
223 nregs
= arm_feature(env
, ARM_FEATURE_VFP3
) ? 32 : 16;
225 stfq_le_p(buf
, env
->vfp
.regs
[reg
]);
228 if (arm_feature(env
, ARM_FEATURE_NEON
)) {
229 /* Aliases for Q regs. */
232 stfq_le_p(buf
, env
->vfp
.regs
[(reg
- 32) * 2]);
233 stfq_le_p(buf
+ 8, env
->vfp
.regs
[(reg
- 32) * 2 + 1]);
237 switch (reg
- nregs
) {
238 case 0: stl_p(buf
, env
->vfp
.xregs
[ARM_VFP_FPSID
]); return 4;
239 case 1: stl_p(buf
, env
->vfp
.xregs
[ARM_VFP_FPSCR
]); return 4;
240 case 2: stl_p(buf
, env
->vfp
.xregs
[ARM_VFP_FPEXC
]); return 4;
245 static int vfp_gdb_set_reg(CPUState
*env
, uint8_t *buf
, int reg
)
249 nregs
= arm_feature(env
, ARM_FEATURE_VFP3
) ? 32 : 16;
251 env
->vfp
.regs
[reg
] = ldfq_le_p(buf
);
254 if (arm_feature(env
, ARM_FEATURE_NEON
)) {
257 env
->vfp
.regs
[(reg
- 32) * 2] = ldfq_le_p(buf
);
258 env
->vfp
.regs
[(reg
- 32) * 2 + 1] = ldfq_le_p(buf
+ 8);
262 switch (reg
- nregs
) {
263 case 0: env
->vfp
.xregs
[ARM_VFP_FPSID
] = ldl_p(buf
); return 4;
264 case 1: env
->vfp
.xregs
[ARM_VFP_FPSCR
] = ldl_p(buf
); return 4;
265 case 2: env
->vfp
.xregs
[ARM_VFP_FPEXC
] = ldl_p(buf
) & (1 << 30); return 4;
270 CPUARMState
*cpu_arm_init(const char *cpu_model
)
274 static int inited
= 0;
276 id
= cpu_arm_find_by_name(cpu_model
);
279 env
= qemu_mallocz(sizeof(CPUARMState
));
283 arm_translate_init();
286 env
->cpu_model_str
= cpu_model
;
287 env
->cp15
.c0_cpuid
= id
;
289 if (arm_feature(env
, ARM_FEATURE_NEON
)) {
290 gdb_register_coprocessor(env
, vfp_gdb_get_reg
, vfp_gdb_set_reg
,
291 51, "arm-neon.xml", 0);
292 } else if (arm_feature(env
, ARM_FEATURE_VFP3
)) {
293 gdb_register_coprocessor(env
, vfp_gdb_get_reg
, vfp_gdb_set_reg
,
294 35, "arm-vfp3.xml", 0);
295 } else if (arm_feature(env
, ARM_FEATURE_VFP
)) {
296 gdb_register_coprocessor(env
, vfp_gdb_get_reg
, vfp_gdb_set_reg
,
297 19, "arm-vfp.xml", 0);
308 static const struct arm_cpu_t arm_cpu_names
[] = {
309 { ARM_CPUID_ARM926
, "arm926"},
310 { ARM_CPUID_ARM946
, "arm946"},
311 { ARM_CPUID_ARM1026
, "arm1026"},
312 { ARM_CPUID_ARM1136
, "arm1136"},
313 { ARM_CPUID_ARM1136_R2
, "arm1136-r2"},
314 { ARM_CPUID_ARM11MPCORE
, "arm11mpcore"},
315 { ARM_CPUID_CORTEXM3
, "cortex-m3"},
316 { ARM_CPUID_CORTEXA8
, "cortex-a8"},
317 { ARM_CPUID_CORTEXA9
, "cortex-a9"},
318 { ARM_CPUID_TI925T
, "ti925t" },
319 { ARM_CPUID_PXA250
, "pxa250" },
320 { ARM_CPUID_PXA255
, "pxa255" },
321 { ARM_CPUID_PXA260
, "pxa260" },
322 { ARM_CPUID_PXA261
, "pxa261" },
323 { ARM_CPUID_PXA262
, "pxa262" },
324 { ARM_CPUID_PXA270
, "pxa270" },
325 { ARM_CPUID_PXA270_A0
, "pxa270-a0" },
326 { ARM_CPUID_PXA270_A1
, "pxa270-a1" },
327 { ARM_CPUID_PXA270_B0
, "pxa270-b0" },
328 { ARM_CPUID_PXA270_B1
, "pxa270-b1" },
329 { ARM_CPUID_PXA270_C0
, "pxa270-c0" },
330 { ARM_CPUID_PXA270_C5
, "pxa270-c5" },
331 { ARM_CPUID_ANY
, "any"},
335 void arm_cpu_list(FILE *f
, int (*cpu_fprintf
)(FILE *f
, const char *fmt
, ...))
339 (*cpu_fprintf
)(f
, "Available CPUs:\n");
340 for (i
= 0; arm_cpu_names
[i
].name
; i
++) {
341 (*cpu_fprintf
)(f
, " %s\n", arm_cpu_names
[i
].name
);
345 /* return 0 if not found */
346 static uint32_t cpu_arm_find_by_name(const char *name
)
352 for (i
= 0; arm_cpu_names
[i
].name
; i
++) {
353 if (strcmp(name
, arm_cpu_names
[i
].name
) == 0) {
354 id
= arm_cpu_names
[i
].id
;
361 void cpu_arm_close(CPUARMState
*env
)
366 uint32_t cpsr_read(CPUARMState
*env
)
370 return env
->uncached_cpsr
| (env
->NF
& 0x80000000) | (ZF
<< 30) |
371 (env
->CF
<< 29) | ((env
->VF
& 0x80000000) >> 3) | (env
->QF
<< 27)
372 | (env
->thumb
<< 5) | ((env
->condexec_bits
& 3) << 25)
373 | ((env
->condexec_bits
& 0xfc) << 8)
377 void cpsr_write(CPUARMState
*env
, uint32_t val
, uint32_t mask
)
379 if (mask
& CPSR_NZCV
) {
380 env
->ZF
= (~val
) & CPSR_Z
;
382 env
->CF
= (val
>> 29) & 1;
383 env
->VF
= (val
<< 3) & 0x80000000;
386 env
->QF
= ((val
& CPSR_Q
) != 0);
388 env
->thumb
= ((val
& CPSR_T
) != 0);
389 if (mask
& CPSR_IT_0_1
) {
390 env
->condexec_bits
&= ~3;
391 env
->condexec_bits
|= (val
>> 25) & 3;
393 if (mask
& CPSR_IT_2_7
) {
394 env
->condexec_bits
&= 3;
395 env
->condexec_bits
|= (val
>> 8) & 0xfc;
397 if (mask
& CPSR_GE
) {
398 env
->GE
= (val
>> 16) & 0xf;
401 if ((env
->uncached_cpsr
^ val
) & mask
& CPSR_M
) {
402 switch_mode(env
, val
& CPSR_M
);
404 mask
&= ~CACHED_CPSR_BITS
;
405 env
->uncached_cpsr
= (env
->uncached_cpsr
& ~mask
) | (val
& mask
);
408 /* Sign/zero extend */
409 uint32_t HELPER(sxtb16
)(uint32_t x
)
412 res
= (uint16_t)(int8_t)x
;
413 res
|= (uint32_t)(int8_t)(x
>> 16) << 16;
417 uint32_t HELPER(uxtb16
)(uint32_t x
)
420 res
= (uint16_t)(uint8_t)x
;
421 res
|= (uint32_t)(uint8_t)(x
>> 16) << 16;
425 uint32_t HELPER(clz
)(uint32_t x
)
430 int32_t HELPER(sdiv
)(int32_t num
, int32_t den
)
434 if (num
== INT_MIN
&& den
== -1)
439 uint32_t HELPER(udiv
)(uint32_t num
, uint32_t den
)
446 uint32_t HELPER(rbit
)(uint32_t x
)
448 x
= ((x
& 0xff000000) >> 24)
449 | ((x
& 0x00ff0000) >> 8)
450 | ((x
& 0x0000ff00) << 8)
451 | ((x
& 0x000000ff) << 24);
452 x
= ((x
& 0xf0f0f0f0) >> 4)
453 | ((x
& 0x0f0f0f0f) << 4);
454 x
= ((x
& 0x88888888) >> 3)
455 | ((x
& 0x44444444) >> 1)
456 | ((x
& 0x22222222) << 1)
457 | ((x
& 0x11111111) << 3);
461 uint32_t HELPER(abs
)(uint32_t x
)
463 return ((int32_t)x
< 0) ? -x
: x
;
466 #if defined(CONFIG_USER_ONLY)
468 void do_interrupt (CPUState
*env
)
470 env
->exception_index
= -1;
473 int cpu_arm_handle_mmu_fault (CPUState
*env
, target_ulong address
, int rw
,
474 int mmu_idx
, int is_softmmu
)
477 env
->exception_index
= EXCP_PREFETCH_ABORT
;
478 env
->cp15
.c6_insn
= address
;
480 env
->exception_index
= EXCP_DATA_ABORT
;
481 env
->cp15
.c6_data
= address
;
486 /* These should probably raise undefined insn exceptions. */
487 void HELPER(set_cp
)(CPUState
*env
, uint32_t insn
, uint32_t val
)
489 int op1
= (insn
>> 8) & 0xf;
490 cpu_abort(env
, "cp%i insn %08x\n", op1
, insn
);
494 uint32_t HELPER(get_cp
)(CPUState
*env
, uint32_t insn
)
496 int op1
= (insn
>> 8) & 0xf;
497 cpu_abort(env
, "cp%i insn %08x\n", op1
, insn
);
501 void HELPER(set_cp15
)(CPUState
*env
, uint32_t insn
, uint32_t val
)
503 cpu_abort(env
, "cp15 insn %08x\n", insn
);
506 uint32_t HELPER(get_cp15
)(CPUState
*env
, uint32_t insn
)
508 cpu_abort(env
, "cp15 insn %08x\n", insn
);
511 /* These should probably raise undefined insn exceptions. */
512 void HELPER(v7m_msr
)(CPUState
*env
, uint32_t reg
, uint32_t val
)
514 cpu_abort(env
, "v7m_mrs %d\n", reg
);
517 uint32_t HELPER(v7m_mrs
)(CPUState
*env
, uint32_t reg
)
519 cpu_abort(env
, "v7m_mrs %d\n", reg
);
523 void switch_mode(CPUState
*env
, int mode
)
525 if (mode
!= ARM_CPU_MODE_USR
)
526 cpu_abort(env
, "Tried to switch out of user mode\n");
529 void HELPER(set_r13_banked
)(CPUState
*env
, uint32_t mode
, uint32_t val
)
531 cpu_abort(env
, "banked r13 write\n");
534 uint32_t HELPER(get_r13_banked
)(CPUState
*env
, uint32_t mode
)
536 cpu_abort(env
, "banked r13 read\n");
542 extern int semihosting_enabled
;
544 /* Map CPU modes onto saved register banks. */
545 static inline int bank_number (int mode
)
548 case ARM_CPU_MODE_USR
:
549 case ARM_CPU_MODE_SYS
:
551 case ARM_CPU_MODE_SVC
:
553 case ARM_CPU_MODE_ABT
:
555 case ARM_CPU_MODE_UND
:
557 case ARM_CPU_MODE_IRQ
:
559 case ARM_CPU_MODE_FIQ
:
562 cpu_abort(cpu_single_env
, "Bad mode %x\n", mode
);
566 void switch_mode(CPUState
*env
, int mode
)
571 old_mode
= env
->uncached_cpsr
& CPSR_M
;
572 if (mode
== old_mode
)
575 if (old_mode
== ARM_CPU_MODE_FIQ
) {
576 memcpy (env
->fiq_regs
, env
->regs
+ 8, 5 * sizeof(uint32_t));
577 memcpy (env
->regs
+ 8, env
->usr_regs
, 5 * sizeof(uint32_t));
578 } else if (mode
== ARM_CPU_MODE_FIQ
) {
579 memcpy (env
->usr_regs
, env
->regs
+ 8, 5 * sizeof(uint32_t));
580 memcpy (env
->regs
+ 8, env
->fiq_regs
, 5 * sizeof(uint32_t));
583 i
= bank_number(old_mode
);
584 env
->banked_r13
[i
] = env
->regs
[13];
585 env
->banked_r14
[i
] = env
->regs
[14];
586 env
->banked_spsr
[i
] = env
->spsr
;
588 i
= bank_number(mode
);
589 env
->regs
[13] = env
->banked_r13
[i
];
590 env
->regs
[14] = env
->banked_r14
[i
];
591 env
->spsr
= env
->banked_spsr
[i
];
594 static void v7m_push(CPUARMState
*env
, uint32_t val
)
597 stl_phys(env
->regs
[13], val
);
600 static uint32_t v7m_pop(CPUARMState
*env
)
603 val
= ldl_phys(env
->regs
[13]);
608 /* Switch to V7M main or process stack pointer. */
609 static void switch_v7m_sp(CPUARMState
*env
, int process
)
612 if (env
->v7m
.current_sp
!= process
) {
613 tmp
= env
->v7m
.other_sp
;
614 env
->v7m
.other_sp
= env
->regs
[13];
616 env
->v7m
.current_sp
= process
;
620 static void do_v7m_exception_exit(CPUARMState
*env
)
625 type
= env
->regs
[15];
626 if (env
->v7m
.exception
!= 0)
627 armv7m_nvic_complete_irq(env
->v7m
.nvic
, env
->v7m
.exception
);
629 /* Switch to the target stack. */
630 switch_v7m_sp(env
, (type
& 4) != 0);
632 env
->regs
[0] = v7m_pop(env
);
633 env
->regs
[1] = v7m_pop(env
);
634 env
->regs
[2] = v7m_pop(env
);
635 env
->regs
[3] = v7m_pop(env
);
636 env
->regs
[12] = v7m_pop(env
);
637 env
->regs
[14] = v7m_pop(env
);
638 env
->regs
[15] = v7m_pop(env
);
640 xpsr_write(env
, xpsr
, 0xfffffdff);
641 /* Undo stack alignment. */
644 /* ??? The exception return type specifies Thread/Handler mode. However
645 this is also implied by the xPSR value. Not sure what to do
646 if there is a mismatch. */
647 /* ??? Likewise for mismatches between the CONTROL register and the stack
651 static void do_interrupt_v7m(CPUARMState
*env
)
653 uint32_t xpsr
= xpsr_read(env
);
658 if (env
->v7m
.current_sp
)
660 if (env
->v7m
.exception
== 0)
663 /* For exceptions we just mark as pending on the NVIC, and let that
665 /* TODO: Need to escalate if the current priority is higher than the
666 one we're raising. */
667 switch (env
->exception_index
) {
669 armv7m_nvic_set_pending(env
->v7m
.nvic
, ARMV7M_EXCP_USAGE
);
673 armv7m_nvic_set_pending(env
->v7m
.nvic
, ARMV7M_EXCP_SVC
);
675 case EXCP_PREFETCH_ABORT
:
676 case EXCP_DATA_ABORT
:
677 armv7m_nvic_set_pending(env
->v7m
.nvic
, ARMV7M_EXCP_MEM
);
680 if (semihosting_enabled
) {
682 nr
= lduw_code(env
->regs
[15]) & 0xff;
685 env
->regs
[0] = do_arm_semihosting(env
);
689 armv7m_nvic_set_pending(env
->v7m
.nvic
, ARMV7M_EXCP_DEBUG
);
692 env
->v7m
.exception
= armv7m_nvic_acknowledge_irq(env
->v7m
.nvic
);
694 case EXCP_EXCEPTION_EXIT
:
695 do_v7m_exception_exit(env
);
698 cpu_abort(env
, "Unhandled exception 0x%x\n", env
->exception_index
);
699 return; /* Never happens. Keep compiler happy. */
702 /* Align stack pointer. */
703 /* ??? Should only do this if Configuration Control Register
704 STACKALIGN bit is set. */
705 if (env
->regs
[13] & 4) {
709 /* Switch to the handler mode. */
711 v7m_push(env
, env
->regs
[15]);
712 v7m_push(env
, env
->regs
[14]);
713 v7m_push(env
, env
->regs
[12]);
714 v7m_push(env
, env
->regs
[3]);
715 v7m_push(env
, env
->regs
[2]);
716 v7m_push(env
, env
->regs
[1]);
717 v7m_push(env
, env
->regs
[0]);
718 switch_v7m_sp(env
, 0);
719 env
->uncached_cpsr
&= ~CPSR_IT
;
721 addr
= ldl_phys(env
->v7m
.vecbase
+ env
->v7m
.exception
* 4);
722 env
->regs
[15] = addr
& 0xfffffffe;
723 env
->thumb
= addr
& 1;
726 /* Handle a CPU exception. */
727 void do_interrupt(CPUARMState
*env
)
735 do_interrupt_v7m(env
);
738 /* TODO: Vectored interrupt controller. */
739 switch (env
->exception_index
) {
741 new_mode
= ARM_CPU_MODE_UND
;
750 if (semihosting_enabled
) {
751 /* Check for semihosting interrupt. */
753 mask
= lduw_code(env
->regs
[15] - 2) & 0xff;
755 mask
= ldl_code(env
->regs
[15] - 4) & 0xffffff;
757 /* Only intercept calls from privileged modes, to provide some
758 semblance of security. */
759 if (((mask
== 0x123456 && !env
->thumb
)
760 || (mask
== 0xab && env
->thumb
))
761 && (env
->uncached_cpsr
& CPSR_M
) != ARM_CPU_MODE_USR
) {
762 env
->regs
[0] = do_arm_semihosting(env
);
766 new_mode
= ARM_CPU_MODE_SVC
;
769 /* The PC already points to the next instruction. */
773 /* See if this is a semihosting syscall. */
774 if (env
->thumb
&& semihosting_enabled
) {
775 mask
= lduw_code(env
->regs
[15]) & 0xff;
777 && (env
->uncached_cpsr
& CPSR_M
) != ARM_CPU_MODE_USR
) {
779 env
->regs
[0] = do_arm_semihosting(env
);
783 /* Fall through to prefetch abort. */
784 case EXCP_PREFETCH_ABORT
:
785 new_mode
= ARM_CPU_MODE_ABT
;
787 mask
= CPSR_A
| CPSR_I
;
790 case EXCP_DATA_ABORT
:
791 new_mode
= ARM_CPU_MODE_ABT
;
793 mask
= CPSR_A
| CPSR_I
;
797 new_mode
= ARM_CPU_MODE_IRQ
;
799 /* Disable IRQ and imprecise data aborts. */
800 mask
= CPSR_A
| CPSR_I
;
804 new_mode
= ARM_CPU_MODE_FIQ
;
806 /* Disable FIQ, IRQ and imprecise data aborts. */
807 mask
= CPSR_A
| CPSR_I
| CPSR_F
;
811 cpu_abort(env
, "Unhandled exception 0x%x\n", env
->exception_index
);
812 return; /* Never happens. Keep compiler happy. */
815 if (env
->cp15
.c1_sys
& (1 << 13)) {
818 switch_mode (env
, new_mode
);
819 env
->spsr
= cpsr_read(env
);
821 env
->condexec_bits
= 0;
822 /* Switch to the new mode, and to the correct instruction set. */
823 env
->uncached_cpsr
= (env
->uncached_cpsr
& ~CPSR_M
) | new_mode
;
824 env
->uncached_cpsr
|= mask
;
825 env
->thumb
= (env
->cp15
.c1_sys
& (1 << 30)) != 0;
826 env
->regs
[14] = env
->regs
[15] + offset
;
827 env
->regs
[15] = addr
;
828 env
->interrupt_request
|= CPU_INTERRUPT_EXITTB
;
831 /* Check section/page access permissions.
832 Returns the page protection flags, or zero if the access is not
834 static inline int check_ap(CPUState
*env
, int ap
, int domain
, int access_type
,
840 return PAGE_READ
| PAGE_WRITE
;
842 if (access_type
== 1)
849 if (access_type
== 1)
851 switch ((env
->cp15
.c1_sys
>> 8) & 3) {
853 return is_user
? 0 : PAGE_READ
;
860 return is_user
? 0 : PAGE_READ
| PAGE_WRITE
;
865 return PAGE_READ
| PAGE_WRITE
;
867 return PAGE_READ
| PAGE_WRITE
;
868 case 4: /* Reserved. */
871 return is_user
? 0 : prot_ro
;
875 if (!arm_feature (env
, ARM_FEATURE_V7
))
883 static uint32_t get_level1_table_address(CPUState
*env
, uint32_t address
)
887 if (address
& env
->cp15
.c2_mask
)
888 table
= env
->cp15
.c2_base1
& 0xffffc000;
890 table
= env
->cp15
.c2_base0
& env
->cp15
.c2_base_mask
;
892 table
|= (address
>> 18) & 0x3ffc;
896 static int get_phys_addr_v5(CPUState
*env
, uint32_t address
, int access_type
,
897 int is_user
, uint32_t *phys_ptr
, int *prot
,
898 target_ulong
*page_size
)
908 /* Pagetable walk. */
909 /* Lookup l1 descriptor. */
910 table
= get_level1_table_address(env
, address
);
911 desc
= ldl_phys(table
);
913 domain
= (env
->cp15
.c3
>> ((desc
>> 4) & 0x1e)) & 3;
915 /* Section translation fault. */
919 if (domain
== 0 || domain
== 2) {
921 code
= 9; /* Section domain fault. */
923 code
= 11; /* Page domain fault. */
928 phys_addr
= (desc
& 0xfff00000) | (address
& 0x000fffff);
929 ap
= (desc
>> 10) & 3;
931 *page_size
= 1024 * 1024;
933 /* Lookup l2 entry. */
935 /* Coarse pagetable. */
936 table
= (desc
& 0xfffffc00) | ((address
>> 10) & 0x3fc);
938 /* Fine pagetable. */
939 table
= (desc
& 0xfffff000) | ((address
>> 8) & 0xffc);
941 desc
= ldl_phys(table
);
943 case 0: /* Page translation fault. */
946 case 1: /* 64k page. */
947 phys_addr
= (desc
& 0xffff0000) | (address
& 0xffff);
948 ap
= (desc
>> (4 + ((address
>> 13) & 6))) & 3;
949 *page_size
= 0x10000;
951 case 2: /* 4k page. */
952 phys_addr
= (desc
& 0xfffff000) | (address
& 0xfff);
953 ap
= (desc
>> (4 + ((address
>> 13) & 6))) & 3;
956 case 3: /* 1k page. */
958 if (arm_feature(env
, ARM_FEATURE_XSCALE
)) {
959 phys_addr
= (desc
& 0xfffff000) | (address
& 0xfff);
961 /* Page translation fault. */
966 phys_addr
= (desc
& 0xfffffc00) | (address
& 0x3ff);
968 ap
= (desc
>> 4) & 3;
972 /* Never happens, but compiler isn't smart enough to tell. */
977 *prot
= check_ap(env
, ap
, domain
, access_type
, is_user
);
979 /* Access permission fault. */
982 *phys_ptr
= phys_addr
;
985 return code
| (domain
<< 4);
988 static int get_phys_addr_v6(CPUState
*env
, uint32_t address
, int access_type
,
989 int is_user
, uint32_t *phys_ptr
, int *prot
,
990 target_ulong
*page_size
)
1001 /* Pagetable walk. */
1002 /* Lookup l1 descriptor. */
1003 table
= get_level1_table_address(env
, address
);
1004 desc
= ldl_phys(table
);
1007 /* Section translation fault. */
1011 } else if (type
== 2 && (desc
& (1 << 18))) {
1015 /* Section or page. */
1016 domain
= (desc
>> 4) & 0x1e;
1018 domain
= (env
->cp15
.c3
>> domain
) & 3;
1019 if (domain
== 0 || domain
== 2) {
1021 code
= 9; /* Section domain fault. */
1023 code
= 11; /* Page domain fault. */
1027 if (desc
& (1 << 18)) {
1029 phys_addr
= (desc
& 0xff000000) | (address
& 0x00ffffff);
1030 *page_size
= 0x1000000;
1033 phys_addr
= (desc
& 0xfff00000) | (address
& 0x000fffff);
1034 *page_size
= 0x100000;
1036 ap
= ((desc
>> 10) & 3) | ((desc
>> 13) & 4);
1037 xn
= desc
& (1 << 4);
1040 /* Lookup l2 entry. */
1041 table
= (desc
& 0xfffffc00) | ((address
>> 10) & 0x3fc);
1042 desc
= ldl_phys(table
);
1043 ap
= ((desc
>> 4) & 3) | ((desc
>> 7) & 4);
1045 case 0: /* Page translation fault. */
1048 case 1: /* 64k page. */
1049 phys_addr
= (desc
& 0xffff0000) | (address
& 0xffff);
1050 xn
= desc
& (1 << 15);
1051 *page_size
= 0x10000;
1053 case 2: case 3: /* 4k page. */
1054 phys_addr
= (desc
& 0xfffff000) | (address
& 0xfff);
1056 *page_size
= 0x1000;
1059 /* Never happens, but compiler isn't smart enough to tell. */
1064 if (xn
&& access_type
== 2)
1067 /* The simplified model uses AP[0] as an access control bit. */
1068 if ((env
->cp15
.c1_sys
& (1 << 29)) && (ap
& 1) == 0) {
1069 /* Access flag fault. */
1070 code
= (code
== 15) ? 6 : 3;
1073 *prot
= check_ap(env
, ap
, domain
, access_type
, is_user
);
1075 /* Access permission fault. */
1078 *phys_ptr
= phys_addr
;
1081 return code
| (domain
<< 4);
1084 static int get_phys_addr_mpu(CPUState
*env
, uint32_t address
, int access_type
,
1085 int is_user
, uint32_t *phys_ptr
, int *prot
)
1091 *phys_ptr
= address
;
1092 for (n
= 7; n
>= 0; n
--) {
1093 base
= env
->cp15
.c6_region
[n
];
1094 if ((base
& 1) == 0)
1096 mask
= 1 << ((base
>> 1) & 0x1f);
1097 /* Keep this shift separate from the above to avoid an
1098 (undefined) << 32. */
1099 mask
= (mask
<< 1) - 1;
1100 if (((base
^ address
) & ~mask
) == 0)
1106 if (access_type
== 2) {
1107 mask
= env
->cp15
.c5_insn
;
1109 mask
= env
->cp15
.c5_data
;
1111 mask
= (mask
>> (n
* 4)) & 0xf;
1118 *prot
= PAGE_READ
| PAGE_WRITE
;
1123 *prot
|= PAGE_WRITE
;
1126 *prot
= PAGE_READ
| PAGE_WRITE
;
1137 /* Bad permission. */
1143 static inline int get_phys_addr(CPUState
*env
, uint32_t address
,
1144 int access_type
, int is_user
,
1145 uint32_t *phys_ptr
, int *prot
,
1146 target_ulong
*page_size
)
1148 /* Fast Context Switch Extension. */
1149 if (address
< 0x02000000)
1150 address
+= env
->cp15
.c13_fcse
;
1152 if ((env
->cp15
.c1_sys
& 1) == 0) {
1153 /* MMU/MPU disabled. */
1154 *phys_ptr
= address
;
1155 *prot
= PAGE_READ
| PAGE_WRITE
;
1156 *page_size
= TARGET_PAGE_SIZE
;
1158 } else if (arm_feature(env
, ARM_FEATURE_MPU
)) {
1159 *page_size
= TARGET_PAGE_SIZE
;
1160 return get_phys_addr_mpu(env
, address
, access_type
, is_user
, phys_ptr
,
1162 } else if (env
->cp15
.c1_sys
& (1 << 23)) {
1163 return get_phys_addr_v6(env
, address
, access_type
, is_user
, phys_ptr
,
1166 return get_phys_addr_v5(env
, address
, access_type
, is_user
, phys_ptr
,
1171 int cpu_arm_handle_mmu_fault (CPUState
*env
, target_ulong address
,
1172 int access_type
, int mmu_idx
, int is_softmmu
)
1175 target_ulong page_size
;
1179 is_user
= mmu_idx
== MMU_USER_IDX
;
1180 ret
= get_phys_addr(env
, address
, access_type
, is_user
, &phys_addr
, &prot
,
1183 /* Map a single [sub]page. */
1184 phys_addr
&= ~(uint32_t)0x3ff;
1185 address
&= ~(uint32_t)0x3ff;
1186 tlb_set_page (env
, address
, phys_addr
, prot
| PAGE_EXEC
, mmu_idx
,
1191 if (access_type
== 2) {
1192 env
->cp15
.c5_insn
= ret
;
1193 env
->cp15
.c6_insn
= address
;
1194 env
->exception_index
= EXCP_PREFETCH_ABORT
;
1196 env
->cp15
.c5_data
= ret
;
1197 if (access_type
== 1 && arm_feature(env
, ARM_FEATURE_V6
))
1198 env
->cp15
.c5_data
|= (1 << 11);
1199 env
->cp15
.c6_data
= address
;
1200 env
->exception_index
= EXCP_DATA_ABORT
;
1205 target_phys_addr_t
cpu_get_phys_page_debug(CPUState
*env
, target_ulong addr
)
1208 target_ulong page_size
;
1212 ret
= get_phys_addr(env
, addr
, 0, 0, &phys_addr
, &prot
, &page_size
);
1220 void HELPER(set_cp
)(CPUState
*env
, uint32_t insn
, uint32_t val
)
1222 int cp_num
= (insn
>> 8) & 0xf;
1223 int cp_info
= (insn
>> 5) & 7;
1224 int src
= (insn
>> 16) & 0xf;
1225 int operand
= insn
& 0xf;
1227 if (env
->cp
[cp_num
].cp_write
)
1228 env
->cp
[cp_num
].cp_write(env
->cp
[cp_num
].opaque
,
1229 cp_info
, src
, operand
, val
);
1232 uint32_t HELPER(get_cp
)(CPUState
*env
, uint32_t insn
)
1234 int cp_num
= (insn
>> 8) & 0xf;
1235 int cp_info
= (insn
>> 5) & 7;
1236 int dest
= (insn
>> 16) & 0xf;
1237 int operand
= insn
& 0xf;
1239 if (env
->cp
[cp_num
].cp_read
)
1240 return env
->cp
[cp_num
].cp_read(env
->cp
[cp_num
].opaque
,
1241 cp_info
, dest
, operand
);
1245 /* Return basic MPU access permission bits. */
1246 static uint32_t simple_mpu_ap_bits(uint32_t val
)
1253 for (i
= 0; i
< 16; i
+= 2) {
1254 ret
|= (val
>> i
) & mask
;
1260 /* Pad basic MPU access permission bits to extended format. */
1261 static uint32_t extended_mpu_ap_bits(uint32_t val
)
1268 for (i
= 0; i
< 16; i
+= 2) {
1269 ret
|= (val
& mask
) << i
;
1275 void HELPER(set_cp15
)(CPUState
*env
, uint32_t insn
, uint32_t val
)
1281 op1
= (insn
>> 21) & 7;
1282 op2
= (insn
>> 5) & 7;
1284 switch ((insn
>> 16) & 0xf) {
1287 if (arm_feature(env
, ARM_FEATURE_XSCALE
))
1289 if (arm_feature(env
, ARM_FEATURE_OMAPCP
))
1291 if (arm_feature(env
, ARM_FEATURE_V7
)
1292 && op1
== 2 && crm
== 0 && op2
== 0) {
1293 env
->cp15
.c0_cssel
= val
& 0xf;
1297 case 1: /* System configuration. */
1298 if (arm_feature(env
, ARM_FEATURE_OMAPCP
))
1302 if (!arm_feature(env
, ARM_FEATURE_XSCALE
) || crm
== 0)
1303 env
->cp15
.c1_sys
= val
;
1304 /* ??? Lots of these bits are not implemented. */
1305 /* This may enable/disable the MMU, so do a TLB flush. */
1308 case 1: /* Auxiliary cotrol register. */
1309 if (arm_feature(env
, ARM_FEATURE_XSCALE
)) {
1310 env
->cp15
.c1_xscaleauxcr
= val
;
1313 /* Not implemented. */
1316 if (arm_feature(env
, ARM_FEATURE_XSCALE
))
1318 if (env
->cp15
.c1_coproc
!= val
) {
1319 env
->cp15
.c1_coproc
= val
;
1320 /* ??? Is this safe when called from within a TB? */
1328 case 2: /* MMU Page table control / MPU cache control. */
1329 if (arm_feature(env
, ARM_FEATURE_MPU
)) {
1332 env
->cp15
.c2_data
= val
;
1335 env
->cp15
.c2_insn
= val
;
1343 env
->cp15
.c2_base0
= val
;
1346 env
->cp15
.c2_base1
= val
;
1350 env
->cp15
.c2_control
= val
;
1351 env
->cp15
.c2_mask
= ~(((uint32_t)0xffffffffu
) >> val
);
1352 env
->cp15
.c2_base_mask
= ~((uint32_t)0x3fffu
>> val
);
1359 case 3: /* MMU Domain access control / MPU write buffer control. */
1361 tlb_flush(env
, 1); /* Flush TLB as domain not tracked in TLB */
1363 case 4: /* Reserved. */
1365 case 5: /* MMU Fault status / MPU access permission. */
1366 if (arm_feature(env
, ARM_FEATURE_OMAPCP
))
1370 if (arm_feature(env
, ARM_FEATURE_MPU
))
1371 val
= extended_mpu_ap_bits(val
);
1372 env
->cp15
.c5_data
= val
;
1375 if (arm_feature(env
, ARM_FEATURE_MPU
))
1376 val
= extended_mpu_ap_bits(val
);
1377 env
->cp15
.c5_insn
= val
;
1380 if (!arm_feature(env
, ARM_FEATURE_MPU
))
1382 env
->cp15
.c5_data
= val
;
1385 if (!arm_feature(env
, ARM_FEATURE_MPU
))
1387 env
->cp15
.c5_insn
= val
;
1393 case 6: /* MMU Fault address / MPU base/size. */
1394 if (arm_feature(env
, ARM_FEATURE_MPU
)) {
1397 env
->cp15
.c6_region
[crm
] = val
;
1399 if (arm_feature(env
, ARM_FEATURE_OMAPCP
))
1403 env
->cp15
.c6_data
= val
;
1405 case 1: /* ??? This is WFAR on armv6 */
1407 env
->cp15
.c6_insn
= val
;
1414 case 7: /* Cache control. */
1415 env
->cp15
.c15_i_max
= 0x000;
1416 env
->cp15
.c15_i_min
= 0xff0;
1417 /* No cache, so nothing to do. */
1418 /* ??? MPCore has VA to PA translation functions. */
1420 case 8: /* MMU TLB control. */
1422 case 0: /* Invalidate all. */
1425 case 1: /* Invalidate single TLB entry. */
1426 tlb_flush_page(env
, val
& TARGET_PAGE_MASK
);
1428 case 2: /* Invalidate on ASID. */
1429 tlb_flush(env
, val
== 0);
1431 case 3: /* Invalidate single entry on MVA. */
1432 /* ??? This is like case 1, but ignores ASID. */
1440 if (arm_feature(env
, ARM_FEATURE_OMAPCP
))
1443 case 0: /* Cache lockdown. */
1445 case 0: /* L1 cache. */
1448 env
->cp15
.c9_data
= val
;
1451 env
->cp15
.c9_insn
= val
;
1457 case 1: /* L2 cache. */
1458 /* Ignore writes to L2 lockdown/auxiliary registers. */
1464 case 1: /* TCM memory region registers. */
1465 /* Not implemented. */
1471 case 10: /* MMU TLB lockdown. */
1472 /* ??? TLB lockdown not implemented. */
1474 case 12: /* Reserved. */
1476 case 13: /* Process ID. */
1479 /* Unlike real hardware the qemu TLB uses virtual addresses,
1480 not modified virtual addresses, so this causes a TLB flush.
1482 if (env
->cp15
.c13_fcse
!= val
)
1484 env
->cp15
.c13_fcse
= val
;
1487 /* This changes the ASID, so do a TLB flush. */
1488 if (env
->cp15
.c13_context
!= val
1489 && !arm_feature(env
, ARM_FEATURE_MPU
))
1491 env
->cp15
.c13_context
= val
;
1497 case 14: /* Reserved. */
1499 case 15: /* Implementation specific. */
1500 if (arm_feature(env
, ARM_FEATURE_XSCALE
)) {
1501 if (op2
== 0 && crm
== 1) {
1502 if (env
->cp15
.c15_cpar
!= (val
& 0x3fff)) {
1503 /* Changes cp0 to cp13 behavior, so needs a TB flush. */
1505 env
->cp15
.c15_cpar
= val
& 0x3fff;
1511 if (arm_feature(env
, ARM_FEATURE_OMAPCP
)) {
1515 case 1: /* Set TI925T configuration. */
1516 env
->cp15
.c15_ticonfig
= val
& 0xe7;
1517 env
->cp15
.c0_cpuid
= (val
& (1 << 5)) ? /* OS_TYPE bit */
1518 ARM_CPUID_TI915T
: ARM_CPUID_TI925T
;
1520 case 2: /* Set I_max. */
1521 env
->cp15
.c15_i_max
= val
;
1523 case 3: /* Set I_min. */
1524 env
->cp15
.c15_i_min
= val
;
1526 case 4: /* Set thread-ID. */
1527 env
->cp15
.c15_threadid
= val
& 0xffff;
1529 case 8: /* Wait-for-interrupt (deprecated). */
1530 cpu_interrupt(env
, CPU_INTERRUPT_HALT
);
1540 /* ??? For debugging only. Should raise illegal instruction exception. */
1541 cpu_abort(env
, "Unimplemented cp15 register write (c%d, c%d, {%d, %d})\n",
1542 (insn
>> 16) & 0xf, crm
, op1
, op2
);
1545 uint32_t HELPER(get_cp15
)(CPUState
*env
, uint32_t insn
)
1551 op1
= (insn
>> 21) & 7;
1552 op2
= (insn
>> 5) & 7;
1554 switch ((insn
>> 16) & 0xf) {
1555 case 0: /* ID codes. */
1561 case 0: /* Device ID. */
1562 return env
->cp15
.c0_cpuid
;
1563 case 1: /* Cache Type. */
1564 return env
->cp15
.c0_cachetype
;
1565 case 2: /* TCM status. */
1567 case 3: /* TLB type register. */
1568 return 0; /* No lockable TLB entries. */
1569 case 5: /* CPU ID */
1570 if (ARM_CPUID(env
) == ARM_CPUID_CORTEXA9
) {
1571 return env
->cpu_index
| 0x80000900;
1573 return env
->cpu_index
;
1579 if (!arm_feature(env
, ARM_FEATURE_V6
))
1581 return env
->cp15
.c0_c1
[op2
];
1583 if (!arm_feature(env
, ARM_FEATURE_V6
))
1585 return env
->cp15
.c0_c2
[op2
];
1586 case 3: case 4: case 5: case 6: case 7:
1592 /* These registers aren't documented on arm11 cores. However
1593 Linux looks at them anyway. */
1594 if (!arm_feature(env
, ARM_FEATURE_V6
))
1598 if (!arm_feature(env
, ARM_FEATURE_V7
))
1603 return env
->cp15
.c0_ccsid
[env
->cp15
.c0_cssel
];
1605 return env
->cp15
.c0_clid
;
1611 if (op2
!= 0 || crm
!= 0)
1613 return env
->cp15
.c0_cssel
;
1617 case 1: /* System configuration. */
1618 if (arm_feature(env
, ARM_FEATURE_OMAPCP
))
1621 case 0: /* Control register. */
1622 return env
->cp15
.c1_sys
;
1623 case 1: /* Auxiliary control register. */
1624 if (arm_feature(env
, ARM_FEATURE_XSCALE
))
1625 return env
->cp15
.c1_xscaleauxcr
;
1626 if (!arm_feature(env
, ARM_FEATURE_AUXCR
))
1628 switch (ARM_CPUID(env
)) {
1629 case ARM_CPUID_ARM1026
:
1631 case ARM_CPUID_ARM1136
:
1632 case ARM_CPUID_ARM1136_R2
:
1634 case ARM_CPUID_ARM11MPCORE
:
1636 case ARM_CPUID_CORTEXA8
:
1638 case ARM_CPUID_CORTEXA9
:
1643 case 2: /* Coprocessor access register. */
1644 if (arm_feature(env
, ARM_FEATURE_XSCALE
))
1646 return env
->cp15
.c1_coproc
;
1650 case 2: /* MMU Page table control / MPU cache control. */
1651 if (arm_feature(env
, ARM_FEATURE_MPU
)) {
1654 return env
->cp15
.c2_data
;
1657 return env
->cp15
.c2_insn
;
1665 return env
->cp15
.c2_base0
;
1667 return env
->cp15
.c2_base1
;
1669 return env
->cp15
.c2_control
;
1674 case 3: /* MMU Domain access control / MPU write buffer control. */
1675 return env
->cp15
.c3
;
1676 case 4: /* Reserved. */
1678 case 5: /* MMU Fault status / MPU access permission. */
1679 if (arm_feature(env
, ARM_FEATURE_OMAPCP
))
1683 if (arm_feature(env
, ARM_FEATURE_MPU
))
1684 return simple_mpu_ap_bits(env
->cp15
.c5_data
);
1685 return env
->cp15
.c5_data
;
1687 if (arm_feature(env
, ARM_FEATURE_MPU
))
1688 return simple_mpu_ap_bits(env
->cp15
.c5_data
);
1689 return env
->cp15
.c5_insn
;
1691 if (!arm_feature(env
, ARM_FEATURE_MPU
))
1693 return env
->cp15
.c5_data
;
1695 if (!arm_feature(env
, ARM_FEATURE_MPU
))
1697 return env
->cp15
.c5_insn
;
1701 case 6: /* MMU Fault address. */
1702 if (arm_feature(env
, ARM_FEATURE_MPU
)) {
1705 return env
->cp15
.c6_region
[crm
];
1707 if (arm_feature(env
, ARM_FEATURE_OMAPCP
))
1711 return env
->cp15
.c6_data
;
1713 if (arm_feature(env
, ARM_FEATURE_V6
)) {
1714 /* Watchpoint Fault Adrress. */
1715 return 0; /* Not implemented. */
1717 /* Instruction Fault Adrress. */
1718 /* Arm9 doesn't have an IFAR, but implementing it anyway
1719 shouldn't do any harm. */
1720 return env
->cp15
.c6_insn
;
1723 if (arm_feature(env
, ARM_FEATURE_V6
)) {
1724 /* Instruction Fault Adrress. */
1725 return env
->cp15
.c6_insn
;
1733 case 7: /* Cache control. */
1734 /* FIXME: Should only clear Z flag if destination is r15. */
1737 case 8: /* MMU TLB control. */
1739 case 9: /* Cache lockdown. */
1741 case 0: /* L1 cache. */
1742 if (arm_feature(env
, ARM_FEATURE_OMAPCP
))
1746 return env
->cp15
.c9_data
;
1748 return env
->cp15
.c9_insn
;
1752 case 1: /* L2 cache */
1755 /* L2 Lockdown and Auxiliary control. */
1760 case 10: /* MMU TLB lockdown. */
1761 /* ??? TLB lockdown not implemented. */
1763 case 11: /* TCM DMA control. */
1764 case 12: /* Reserved. */
1766 case 13: /* Process ID. */
1769 return env
->cp15
.c13_fcse
;
1771 return env
->cp15
.c13_context
;
1775 case 14: /* Reserved. */
1777 case 15: /* Implementation specific. */
1778 if (arm_feature(env
, ARM_FEATURE_XSCALE
)) {
1779 if (op2
== 0 && crm
== 1)
1780 return env
->cp15
.c15_cpar
;
1784 if (arm_feature(env
, ARM_FEATURE_OMAPCP
)) {
1788 case 1: /* Read TI925T configuration. */
1789 return env
->cp15
.c15_ticonfig
;
1790 case 2: /* Read I_max. */
1791 return env
->cp15
.c15_i_max
;
1792 case 3: /* Read I_min. */
1793 return env
->cp15
.c15_i_min
;
1794 case 4: /* Read thread-ID. */
1795 return env
->cp15
.c15_threadid
;
1796 case 8: /* TI925T_status */
1799 /* TODO: Peripheral port remap register:
1800 * On OMAP2 mcr p15, 0, rn, c15, c2, 4 sets up the interrupt
1801 * controller base address at $rn & ~0xfff and map size of
1802 * 0x200 << ($rn & 0xfff), when MMU is off. */
1808 /* ??? For debugging only. Should raise illegal instruction exception. */
1809 cpu_abort(env
, "Unimplemented cp15 register read (c%d, c%d, {%d, %d})\n",
1810 (insn
>> 16) & 0xf, crm
, op1
, op2
);
1814 void HELPER(set_r13_banked
)(CPUState
*env
, uint32_t mode
, uint32_t val
)
1816 env
->banked_r13
[bank_number(mode
)] = val
;
1819 uint32_t HELPER(get_r13_banked
)(CPUState
*env
, uint32_t mode
)
1821 return env
->banked_r13
[bank_number(mode
)];
1824 uint32_t HELPER(v7m_mrs
)(CPUState
*env
, uint32_t reg
)
1828 return xpsr_read(env
) & 0xf8000000;
1830 return xpsr_read(env
) & 0xf80001ff;
1832 return xpsr_read(env
) & 0xff00fc00;
1834 return xpsr_read(env
) & 0xff00fdff;
1836 return xpsr_read(env
) & 0x000001ff;
1838 return xpsr_read(env
) & 0x0700fc00;
1840 return xpsr_read(env
) & 0x0700edff;
1842 return env
->v7m
.current_sp
? env
->v7m
.other_sp
: env
->regs
[13];
1844 return env
->v7m
.current_sp
? env
->regs
[13] : env
->v7m
.other_sp
;
1845 case 16: /* PRIMASK */
1846 return (env
->uncached_cpsr
& CPSR_I
) != 0;
1847 case 17: /* FAULTMASK */
1848 return (env
->uncached_cpsr
& CPSR_F
) != 0;
1849 case 18: /* BASEPRI */
1850 case 19: /* BASEPRI_MAX */
1851 return env
->v7m
.basepri
;
1852 case 20: /* CONTROL */
1853 return env
->v7m
.control
;
1855 /* ??? For debugging only. */
1856 cpu_abort(env
, "Unimplemented system register read (%d)\n", reg
);
1861 void HELPER(v7m_msr
)(CPUState
*env
, uint32_t reg
, uint32_t val
)
1865 xpsr_write(env
, val
, 0xf8000000);
1868 xpsr_write(env
, val
, 0xf8000000);
1871 xpsr_write(env
, val
, 0xfe00fc00);
1874 xpsr_write(env
, val
, 0xfe00fc00);
1877 /* IPSR bits are readonly. */
1880 xpsr_write(env
, val
, 0x0600fc00);
1883 xpsr_write(env
, val
, 0x0600fc00);
1886 if (env
->v7m
.current_sp
)
1887 env
->v7m
.other_sp
= val
;
1889 env
->regs
[13] = val
;
1892 if (env
->v7m
.current_sp
)
1893 env
->regs
[13] = val
;
1895 env
->v7m
.other_sp
= val
;
1897 case 16: /* PRIMASK */
1899 env
->uncached_cpsr
|= CPSR_I
;
1901 env
->uncached_cpsr
&= ~CPSR_I
;
1903 case 17: /* FAULTMASK */
1905 env
->uncached_cpsr
|= CPSR_F
;
1907 env
->uncached_cpsr
&= ~CPSR_F
;
1909 case 18: /* BASEPRI */
1910 env
->v7m
.basepri
= val
& 0xff;
1912 case 19: /* BASEPRI_MAX */
1914 if (val
!= 0 && (val
< env
->v7m
.basepri
|| env
->v7m
.basepri
== 0))
1915 env
->v7m
.basepri
= val
;
1917 case 20: /* CONTROL */
1918 env
->v7m
.control
= val
& 3;
1919 switch_v7m_sp(env
, (val
& 2) != 0);
1922 /* ??? For debugging only. */
1923 cpu_abort(env
, "Unimplemented system register write (%d)\n", reg
);
1928 void cpu_arm_set_cp_io(CPUARMState
*env
, int cpnum
,
1929 ARMReadCPFunc
*cp_read
, ARMWriteCPFunc
*cp_write
,
1932 if (cpnum
< 0 || cpnum
> 14) {
1933 cpu_abort(env
, "Bad coprocessor number: %i\n", cpnum
);
1937 env
->cp
[cpnum
].cp_read
= cp_read
;
1938 env
->cp
[cpnum
].cp_write
= cp_write
;
1939 env
->cp
[cpnum
].opaque
= opaque
;
1944 /* Note that signed overflow is undefined in C. The following routines are
1945 careful to use unsigned types where modulo arithmetic is required.
1946 Failure to do so _will_ break on newer gcc. */
1948 /* Signed saturating arithmetic. */
1950 /* Perform 16-bit signed saturating addition. */
1951 static inline uint16_t add16_sat(uint16_t a
, uint16_t b
)
1956 if (((res
^ a
) & 0x8000) && !((a
^ b
) & 0x8000)) {
1965 /* Perform 8-bit signed saturating addition. */
1966 static inline uint8_t add8_sat(uint8_t a
, uint8_t b
)
1971 if (((res
^ a
) & 0x80) && !((a
^ b
) & 0x80)) {
1980 /* Perform 16-bit signed saturating subtraction. */
1981 static inline uint16_t sub16_sat(uint16_t a
, uint16_t b
)
1986 if (((res
^ a
) & 0x8000) && ((a
^ b
) & 0x8000)) {
1995 /* Perform 8-bit signed saturating subtraction. */
1996 static inline uint8_t sub8_sat(uint8_t a
, uint8_t b
)
2001 if (((res
^ a
) & 0x80) && ((a
^ b
) & 0x80)) {
2010 #define ADD16(a, b, n) RESULT(add16_sat(a, b), n, 16);
2011 #define SUB16(a, b, n) RESULT(sub16_sat(a, b), n, 16);
2012 #define ADD8(a, b, n) RESULT(add8_sat(a, b), n, 8);
2013 #define SUB8(a, b, n) RESULT(sub8_sat(a, b), n, 8);
2016 #include "op_addsub.h"
2018 /* Unsigned saturating arithmetic. */
2019 static inline uint16_t add16_usat(uint16_t a
, uint16_t b
)
2028 static inline uint16_t sub16_usat(uint16_t a
, uint16_t b
)
2036 static inline uint8_t add8_usat(uint8_t a
, uint8_t b
)
2045 static inline uint8_t sub8_usat(uint8_t a
, uint8_t b
)
2053 #define ADD16(a, b, n) RESULT(add16_usat(a, b), n, 16);
2054 #define SUB16(a, b, n) RESULT(sub16_usat(a, b), n, 16);
2055 #define ADD8(a, b, n) RESULT(add8_usat(a, b), n, 8);
2056 #define SUB8(a, b, n) RESULT(sub8_usat(a, b), n, 8);
2059 #include "op_addsub.h"
2061 /* Signed modulo arithmetic. */
2062 #define SARITH16(a, b, n, op) do { \
2064 sum = (int16_t)((uint16_t)(a) op (uint16_t)(b)); \
2065 RESULT(sum, n, 16); \
2067 ge |= 3 << (n * 2); \
2070 #define SARITH8(a, b, n, op) do { \
2072 sum = (int8_t)((uint8_t)(a) op (uint8_t)(b)); \
2073 RESULT(sum, n, 8); \
2079 #define ADD16(a, b, n) SARITH16(a, b, n, +)
2080 #define SUB16(a, b, n) SARITH16(a, b, n, -)
2081 #define ADD8(a, b, n) SARITH8(a, b, n, +)
2082 #define SUB8(a, b, n) SARITH8(a, b, n, -)
2086 #include "op_addsub.h"
2088 /* Unsigned modulo arithmetic. */
2089 #define ADD16(a, b, n) do { \
2091 sum = (uint32_t)(uint16_t)(a) + (uint32_t)(uint16_t)(b); \
2092 RESULT(sum, n, 16); \
2093 if ((sum >> 16) == 1) \
2094 ge |= 3 << (n * 2); \
2097 #define ADD8(a, b, n) do { \
2099 sum = (uint32_t)(uint8_t)(a) + (uint32_t)(uint8_t)(b); \
2100 RESULT(sum, n, 8); \
2101 if ((sum >> 8) == 1) \
2105 #define SUB16(a, b, n) do { \
2107 sum = (uint32_t)(uint16_t)(a) - (uint32_t)(uint16_t)(b); \
2108 RESULT(sum, n, 16); \
2109 if ((sum >> 16) == 0) \
2110 ge |= 3 << (n * 2); \
2113 #define SUB8(a, b, n) do { \
2115 sum = (uint32_t)(uint8_t)(a) - (uint32_t)(uint8_t)(b); \
2116 RESULT(sum, n, 8); \
2117 if ((sum >> 8) == 0) \
2124 #include "op_addsub.h"
2126 /* Halved signed arithmetic. */
2127 #define ADD16(a, b, n) \
2128 RESULT(((int32_t)(int16_t)(a) + (int32_t)(int16_t)(b)) >> 1, n, 16)
2129 #define SUB16(a, b, n) \
2130 RESULT(((int32_t)(int16_t)(a) - (int32_t)(int16_t)(b)) >> 1, n, 16)
2131 #define ADD8(a, b, n) \
2132 RESULT(((int32_t)(int8_t)(a) + (int32_t)(int8_t)(b)) >> 1, n, 8)
2133 #define SUB8(a, b, n) \
2134 RESULT(((int32_t)(int8_t)(a) - (int32_t)(int8_t)(b)) >> 1, n, 8)
2137 #include "op_addsub.h"
2139 /* Halved unsigned arithmetic. */
2140 #define ADD16(a, b, n) \
2141 RESULT(((uint32_t)(uint16_t)(a) + (uint32_t)(uint16_t)(b)) >> 1, n, 16)
2142 #define SUB16(a, b, n) \
2143 RESULT(((uint32_t)(uint16_t)(a) - (uint32_t)(uint16_t)(b)) >> 1, n, 16)
2144 #define ADD8(a, b, n) \
2145 RESULT(((uint32_t)(uint8_t)(a) + (uint32_t)(uint8_t)(b)) >> 1, n, 8)
2146 #define SUB8(a, b, n) \
2147 RESULT(((uint32_t)(uint8_t)(a) - (uint32_t)(uint8_t)(b)) >> 1, n, 8)
2150 #include "op_addsub.h"
2152 static inline uint8_t do_usad(uint8_t a
, uint8_t b
)
2160 /* Unsigned sum of absolute byte differences. */
2161 uint32_t HELPER(usad8
)(uint32_t a
, uint32_t b
)
2164 sum
= do_usad(a
, b
);
2165 sum
+= do_usad(a
>> 8, b
>> 8);
2166 sum
+= do_usad(a
>> 16, b
>>16);
2167 sum
+= do_usad(a
>> 24, b
>> 24);
2171 /* For ARMv6 SEL instruction. */
2172 uint32_t HELPER(sel_flags
)(uint32_t flags
, uint32_t a
, uint32_t b
)
2185 return (a
& mask
) | (b
& ~mask
);
2188 uint32_t HELPER(logicq_cc
)(uint64_t val
)
2190 return (val
>> 32) | (val
!= 0);
2193 /* VFP support. We follow the convention used for VFP instrunctions:
2194 Single precition routines have a "s" suffix, double precision a
2197 /* Convert host exception flags to vfp form. */
2198 static inline int vfp_exceptbits_from_host(int host_bits
)
2200 int target_bits
= 0;
2202 if (host_bits
& float_flag_invalid
)
2204 if (host_bits
& float_flag_divbyzero
)
2206 if (host_bits
& float_flag_overflow
)
2208 if (host_bits
& float_flag_underflow
)
2210 if (host_bits
& float_flag_inexact
)
2211 target_bits
|= 0x10;
2215 uint32_t HELPER(vfp_get_fpscr
)(CPUState
*env
)
2220 fpscr
= (env
->vfp
.xregs
[ARM_VFP_FPSCR
] & 0xffc8ffff)
2221 | (env
->vfp
.vec_len
<< 16)
2222 | (env
->vfp
.vec_stride
<< 20);
2223 i
= get_float_exception_flags(&env
->vfp
.fp_status
);
2224 fpscr
|= vfp_exceptbits_from_host(i
);
2228 /* Convert vfp exception flags to target form. */
2229 static inline int vfp_exceptbits_to_host(int target_bits
)
2233 if (target_bits
& 1)
2234 host_bits
|= float_flag_invalid
;
2235 if (target_bits
& 2)
2236 host_bits
|= float_flag_divbyzero
;
2237 if (target_bits
& 4)
2238 host_bits
|= float_flag_overflow
;
2239 if (target_bits
& 8)
2240 host_bits
|= float_flag_underflow
;
2241 if (target_bits
& 0x10)
2242 host_bits
|= float_flag_inexact
;
2246 void HELPER(vfp_set_fpscr
)(CPUState
*env
, uint32_t val
)
2251 changed
= env
->vfp
.xregs
[ARM_VFP_FPSCR
];
2252 env
->vfp
.xregs
[ARM_VFP_FPSCR
] = (val
& 0xffc8ffff);
2253 env
->vfp
.vec_len
= (val
>> 16) & 7;
2254 env
->vfp
.vec_stride
= (val
>> 20) & 3;
2257 if (changed
& (3 << 22)) {
2258 i
= (val
>> 22) & 3;
2261 i
= float_round_nearest_even
;
2267 i
= float_round_down
;
2270 i
= float_round_to_zero
;
2273 set_float_rounding_mode(i
, &env
->vfp
.fp_status
);
2275 if (changed
& (1 << 24))
2276 set_flush_to_zero((val
& (1 << 24)) != 0, &env
->vfp
.fp_status
);
2277 if (changed
& (1 << 25))
2278 set_default_nan_mode((val
& (1 << 25)) != 0, &env
->vfp
.fp_status
);
2280 i
= vfp_exceptbits_to_host((val
>> 8) & 0x1f);
2281 set_float_exception_flags(i
, &env
->vfp
.fp_status
);
2284 #define VFP_HELPER(name, p) HELPER(glue(glue(vfp_,name),p))
2286 #define VFP_BINOP(name) \
2287 float32 VFP_HELPER(name, s)(float32 a, float32 b, CPUState *env) \
2289 return float32_ ## name (a, b, &env->vfp.fp_status); \
2291 float64 VFP_HELPER(name, d)(float64 a, float64 b, CPUState *env) \
2293 return float64_ ## name (a, b, &env->vfp.fp_status); \
2301 float32
VFP_HELPER(neg
, s
)(float32 a
)
2303 return float32_chs(a
);
2306 float64
VFP_HELPER(neg
, d
)(float64 a
)
2308 return float64_chs(a
);
2311 float32
VFP_HELPER(abs
, s
)(float32 a
)
2313 return float32_abs(a
);
2316 float64
VFP_HELPER(abs
, d
)(float64 a
)
2318 return float64_abs(a
);
2321 float32
VFP_HELPER(sqrt
, s
)(float32 a
, CPUState
*env
)
2323 return float32_sqrt(a
, &env
->vfp
.fp_status
);
2326 float64
VFP_HELPER(sqrt
, d
)(float64 a
, CPUState
*env
)
2328 return float64_sqrt(a
, &env
->vfp
.fp_status
);
2331 /* XXX: check quiet/signaling case */
2332 #define DO_VFP_cmp(p, type) \
2333 void VFP_HELPER(cmp, p)(type a, type b, CPUState *env) \
2336 switch(type ## _compare_quiet(a, b, &env->vfp.fp_status)) { \
2337 case 0: flags = 0x6; break; \
2338 case -1: flags = 0x8; break; \
2339 case 1: flags = 0x2; break; \
2340 default: case 2: flags = 0x3; break; \
2342 env->vfp.xregs[ARM_VFP_FPSCR] = (flags << 28) \
2343 | (env->vfp.xregs[ARM_VFP_FPSCR] & 0x0fffffff); \
2345 void VFP_HELPER(cmpe, p)(type a, type b, CPUState *env) \
2348 switch(type ## _compare(a, b, &env->vfp.fp_status)) { \
2349 case 0: flags = 0x6; break; \
2350 case -1: flags = 0x8; break; \
2351 case 1: flags = 0x2; break; \
2352 default: case 2: flags = 0x3; break; \
2354 env->vfp.xregs[ARM_VFP_FPSCR] = (flags << 28) \
2355 | (env->vfp.xregs[ARM_VFP_FPSCR] & 0x0fffffff); \
2357 DO_VFP_cmp(s
, float32
)
2358 DO_VFP_cmp(d
, float64
)
2361 /* Helper routines to perform bitwise copies between float and int. */
2362 static inline float32
vfp_itos(uint32_t i
)
2373 static inline uint32_t vfp_stoi(float32 s
)
2384 static inline float64
vfp_itod(uint64_t i
)
2395 static inline uint64_t vfp_dtoi(float64 d
)
2406 /* Integer to float conversion. */
2407 float32
VFP_HELPER(uito
, s
)(float32 x
, CPUState
*env
)
2409 return uint32_to_float32(vfp_stoi(x
), &env
->vfp
.fp_status
);
2412 float64
VFP_HELPER(uito
, d
)(float32 x
, CPUState
*env
)
2414 return uint32_to_float64(vfp_stoi(x
), &env
->vfp
.fp_status
);
2417 float32
VFP_HELPER(sito
, s
)(float32 x
, CPUState
*env
)
2419 return int32_to_float32(vfp_stoi(x
), &env
->vfp
.fp_status
);
2422 float64
VFP_HELPER(sito
, d
)(float32 x
, CPUState
*env
)
2424 return int32_to_float64(vfp_stoi(x
), &env
->vfp
.fp_status
);
2427 /* Float to integer conversion. */
2428 float32
VFP_HELPER(toui
, s
)(float32 x
, CPUState
*env
)
2430 return vfp_itos(float32_to_uint32(x
, &env
->vfp
.fp_status
));
2433 float32
VFP_HELPER(toui
, d
)(float64 x
, CPUState
*env
)
2435 return vfp_itos(float64_to_uint32(x
, &env
->vfp
.fp_status
));
2438 float32
VFP_HELPER(tosi
, s
)(float32 x
, CPUState
*env
)
2440 return vfp_itos(float32_to_int32(x
, &env
->vfp
.fp_status
));
2443 float32
VFP_HELPER(tosi
, d
)(float64 x
, CPUState
*env
)
2445 return vfp_itos(float64_to_int32(x
, &env
->vfp
.fp_status
));
2448 float32
VFP_HELPER(touiz
, s
)(float32 x
, CPUState
*env
)
2450 return vfp_itos(float32_to_uint32_round_to_zero(x
, &env
->vfp
.fp_status
));
2453 float32
VFP_HELPER(touiz
, d
)(float64 x
, CPUState
*env
)
2455 return vfp_itos(float64_to_uint32_round_to_zero(x
, &env
->vfp
.fp_status
));
2458 float32
VFP_HELPER(tosiz
, s
)(float32 x
, CPUState
*env
)
2460 return vfp_itos(float32_to_int32_round_to_zero(x
, &env
->vfp
.fp_status
));
2463 float32
VFP_HELPER(tosiz
, d
)(float64 x
, CPUState
*env
)
2465 return vfp_itos(float64_to_int32_round_to_zero(x
, &env
->vfp
.fp_status
));
2468 /* floating point conversion */
2469 float64
VFP_HELPER(fcvtd
, s
)(float32 x
, CPUState
*env
)
2471 return float32_to_float64(x
, &env
->vfp
.fp_status
);
2474 float32
VFP_HELPER(fcvts
, d
)(float64 x
, CPUState
*env
)
2476 return float64_to_float32(x
, &env
->vfp
.fp_status
);
2479 /* VFP3 fixed point conversion. */
2480 #define VFP_CONV_FIX(name, p, ftype, itype, sign) \
2481 ftype VFP_HELPER(name##to, p)(ftype x, uint32_t shift, CPUState *env) \
2484 tmp = sign##int32_to_##ftype ((itype)vfp_##p##toi(x), \
2485 &env->vfp.fp_status); \
2486 return ftype##_scalbn(tmp, -(int)shift, &env->vfp.fp_status); \
2488 ftype VFP_HELPER(to##name, p)(ftype x, uint32_t shift, CPUState *env) \
2491 tmp = ftype##_scalbn(x, shift, &env->vfp.fp_status); \
2492 return vfp_ito##p((itype)ftype##_to_##sign##int32_round_to_zero(tmp, \
2493 &env->vfp.fp_status)); \
2496 VFP_CONV_FIX(sh
, d
, float64
, int16
, )
2497 VFP_CONV_FIX(sl
, d
, float64
, int32
, )
2498 VFP_CONV_FIX(uh
, d
, float64
, uint16
, u
)
2499 VFP_CONV_FIX(ul
, d
, float64
, uint32
, u
)
2500 VFP_CONV_FIX(sh
, s
, float32
, int16
, )
2501 VFP_CONV_FIX(sl
, s
, float32
, int32
, )
2502 VFP_CONV_FIX(uh
, s
, float32
, uint16
, u
)
2503 VFP_CONV_FIX(ul
, s
, float32
, uint32
, u
)
2506 /* Half precision conversions. */
2507 float32
HELPER(vfp_fcvt_f16_to_f32
)(uint32_t a
, CPUState
*env
)
2509 float_status
*s
= &env
->vfp
.fp_status
;
2510 int ieee
= (env
->vfp
.xregs
[ARM_VFP_FPSCR
] & (1 << 26)) == 0;
2511 return float16_to_float32(a
, ieee
, s
);
2514 uint32_t HELPER(vfp_fcvt_f32_to_f16
)(float32 a
, CPUState
*env
)
2516 float_status
*s
= &env
->vfp
.fp_status
;
2517 int ieee
= (env
->vfp
.xregs
[ARM_VFP_FPSCR
] & (1 << 26)) == 0;
2518 return float32_to_float16(a
, ieee
, s
);
2521 float32
HELPER(recps_f32
)(float32 a
, float32 b
, CPUState
*env
)
2523 float_status
*s
= &env
->vfp
.fp_status
;
2524 float32 two
= int32_to_float32(2, s
);
2525 return float32_sub(two
, float32_mul(a
, b
, s
), s
);
2528 float32
HELPER(rsqrts_f32
)(float32 a
, float32 b
, CPUState
*env
)
2530 float_status
*s
= &env
->vfp
.fp_status
;
2531 float32 three
= int32_to_float32(3, s
);
2532 return float32_sub(three
, float32_mul(a
, b
, s
), s
);
2537 /* TODO: The architecture specifies the value that the estimate functions
2538 should return. We return the exact reciprocal/root instead. */
2539 float32
HELPER(recpe_f32
)(float32 a
, CPUState
*env
)
2541 float_status
*s
= &env
->vfp
.fp_status
;
2542 float32 one
= int32_to_float32(1, s
);
2543 return float32_div(one
, a
, s
);
2546 float32
HELPER(rsqrte_f32
)(float32 a
, CPUState
*env
)
2548 float_status
*s
= &env
->vfp
.fp_status
;
2549 float32 one
= int32_to_float32(1, s
);
2550 return float32_div(one
, float32_sqrt(a
, s
), s
);
2553 uint32_t HELPER(recpe_u32
)(uint32_t a
, CPUState
*env
)
2555 float_status
*s
= &env
->vfp
.fp_status
;
2557 tmp
= int32_to_float32(a
, s
);
2558 tmp
= float32_scalbn(tmp
, -32, s
);
2559 tmp
= helper_recpe_f32(tmp
, env
);
2560 tmp
= float32_scalbn(tmp
, 31, s
);
2561 return float32_to_int32(tmp
, s
);
2564 uint32_t HELPER(rsqrte_u32
)(uint32_t a
, CPUState
*env
)
2566 float_status
*s
= &env
->vfp
.fp_status
;
2568 tmp
= int32_to_float32(a
, s
);
2569 tmp
= float32_scalbn(tmp
, -32, s
);
2570 tmp
= helper_rsqrte_f32(tmp
, env
);
2571 tmp
= float32_scalbn(tmp
, 31, s
);
2572 return float32_to_int32(tmp
, s
);
2575 void HELPER(set_teecr
)(CPUState
*env
, uint32_t val
)
2578 if (env
->teecr
!= val
) {