4 * Copyright (c) 2005-2007 CodeSourcery, LLC
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.
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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
21 #include "internals.h"
23 #define SIGNBIT (uint32_t)0x80000000
24 #define SIGNBIT64 ((uint64_t)1 << 63)
26 static void raise_exception(CPUARMState
*env
, int tt
)
28 ARMCPU
*cpu
= arm_env_get_cpu(env
);
29 CPUState
*cs
= CPU(cpu
);
31 cs
->exception_index
= tt
;
35 uint32_t HELPER(neon_tbl
)(CPUARMState
*env
, uint32_t ireg
, uint32_t def
,
36 uint32_t rn
, uint32_t maxindex
)
43 table
= (uint64_t *)&env
->vfp
.regs
[rn
];
45 for (shift
= 0; shift
< 32; shift
+= 8) {
46 index
= (ireg
>> shift
) & 0xff;
47 if (index
< maxindex
) {
48 tmp
= (table
[index
>> 3] >> ((index
& 7) << 3)) & 0xff;
51 val
|= def
& (0xff << shift
);
57 #if !defined(CONFIG_USER_ONLY)
59 #include "exec/softmmu_exec.h"
61 #define MMUSUFFIX _mmu
64 #include "exec/softmmu_template.h"
67 #include "exec/softmmu_template.h"
70 #include "exec/softmmu_template.h"
73 #include "exec/softmmu_template.h"
75 /* try to fill the TLB and return an exception if error. If retaddr is
76 * NULL, it means that the function was called in C code (i.e. not
77 * from generated code or from helper.c)
79 void tlb_fill(CPUState
*cs
, target_ulong addr
, int is_write
, int mmu_idx
,
84 ret
= arm_cpu_handle_mmu_fault(cs
, addr
, is_write
, mmu_idx
);
86 ARMCPU
*cpu
= ARM_CPU(cs
);
87 CPUARMState
*env
= &cpu
->env
;
90 /* now we have a real cpu fault */
91 cpu_restore_state(cs
, retaddr
);
93 raise_exception(env
, cs
->exception_index
);
98 uint32_t HELPER(add_setq
)(CPUARMState
*env
, uint32_t a
, uint32_t b
)
100 uint32_t res
= a
+ b
;
101 if (((res
^ a
) & SIGNBIT
) && !((a
^ b
) & SIGNBIT
))
106 uint32_t HELPER(add_saturate
)(CPUARMState
*env
, uint32_t a
, uint32_t b
)
108 uint32_t res
= a
+ b
;
109 if (((res
^ a
) & SIGNBIT
) && !((a
^ b
) & SIGNBIT
)) {
111 res
= ~(((int32_t)a
>> 31) ^ SIGNBIT
);
116 uint32_t HELPER(sub_saturate
)(CPUARMState
*env
, uint32_t a
, uint32_t b
)
118 uint32_t res
= a
- b
;
119 if (((res
^ a
) & SIGNBIT
) && ((a
^ b
) & SIGNBIT
)) {
121 res
= ~(((int32_t)a
>> 31) ^ SIGNBIT
);
126 uint32_t HELPER(double_saturate
)(CPUARMState
*env
, int32_t val
)
129 if (val
>= 0x40000000) {
132 } else if (val
<= (int32_t)0xc0000000) {
141 uint32_t HELPER(add_usaturate
)(CPUARMState
*env
, uint32_t a
, uint32_t b
)
143 uint32_t res
= a
+ b
;
151 uint32_t HELPER(sub_usaturate
)(CPUARMState
*env
, uint32_t a
, uint32_t b
)
153 uint32_t res
= a
- b
;
161 /* Signed saturation. */
162 static inline uint32_t do_ssat(CPUARMState
*env
, int32_t val
, int shift
)
168 mask
= (1u << shift
) - 1;
172 } else if (top
< -1) {
179 /* Unsigned saturation. */
180 static inline uint32_t do_usat(CPUARMState
*env
, int32_t val
, int shift
)
184 max
= (1u << shift
) - 1;
188 } else if (val
> max
) {
195 /* Signed saturate. */
196 uint32_t HELPER(ssat
)(CPUARMState
*env
, uint32_t x
, uint32_t shift
)
198 return do_ssat(env
, x
, shift
);
201 /* Dual halfword signed saturate. */
202 uint32_t HELPER(ssat16
)(CPUARMState
*env
, uint32_t x
, uint32_t shift
)
206 res
= (uint16_t)do_ssat(env
, (int16_t)x
, shift
);
207 res
|= do_ssat(env
, ((int32_t)x
) >> 16, shift
) << 16;
211 /* Unsigned saturate. */
212 uint32_t HELPER(usat
)(CPUARMState
*env
, uint32_t x
, uint32_t shift
)
214 return do_usat(env
, x
, shift
);
217 /* Dual halfword unsigned saturate. */
218 uint32_t HELPER(usat16
)(CPUARMState
*env
, uint32_t x
, uint32_t shift
)
222 res
= (uint16_t)do_usat(env
, (int16_t)x
, shift
);
223 res
|= do_usat(env
, ((int32_t)x
) >> 16, shift
) << 16;
227 void HELPER(wfi
)(CPUARMState
*env
)
229 CPUState
*cs
= CPU(arm_env_get_cpu(env
));
231 cs
->exception_index
= EXCP_HLT
;
236 void HELPER(wfe
)(CPUARMState
*env
)
238 CPUState
*cs
= CPU(arm_env_get_cpu(env
));
240 /* Don't actually halt the CPU, just yield back to top
243 cs
->exception_index
= EXCP_YIELD
;
247 void HELPER(exception
)(CPUARMState
*env
, uint32_t excp
)
249 CPUState
*cs
= CPU(arm_env_get_cpu(env
));
251 cs
->exception_index
= excp
;
255 uint32_t HELPER(cpsr_read
)(CPUARMState
*env
)
257 return cpsr_read(env
) & ~CPSR_EXEC
;
260 void HELPER(cpsr_write
)(CPUARMState
*env
, uint32_t val
, uint32_t mask
)
262 cpsr_write(env
, val
, mask
);
265 /* Access to user mode registers from privileged modes. */
266 uint32_t HELPER(get_user_reg
)(CPUARMState
*env
, uint32_t regno
)
271 val
= env
->banked_r13
[0];
272 } else if (regno
== 14) {
273 val
= env
->banked_r14
[0];
274 } else if (regno
>= 8
275 && (env
->uncached_cpsr
& 0x1f) == ARM_CPU_MODE_FIQ
) {
276 val
= env
->usr_regs
[regno
- 8];
278 val
= env
->regs
[regno
];
283 void HELPER(set_user_reg
)(CPUARMState
*env
, uint32_t regno
, uint32_t val
)
286 env
->banked_r13
[0] = val
;
287 } else if (regno
== 14) {
288 env
->banked_r14
[0] = val
;
289 } else if (regno
>= 8
290 && (env
->uncached_cpsr
& 0x1f) == ARM_CPU_MODE_FIQ
) {
291 env
->usr_regs
[regno
- 8] = val
;
293 env
->regs
[regno
] = val
;
297 void HELPER(access_check_cp_reg
)(CPUARMState
*env
, void *rip
)
299 const ARMCPRegInfo
*ri
= rip
;
300 switch (ri
->accessfn(env
, ri
)) {
304 case CP_ACCESS_TRAP_UNCATEGORIZED
:
305 /* These cases will eventually need to generate different
306 * syndrome information.
310 g_assert_not_reached();
312 raise_exception(env
, EXCP_UDEF
);
315 void HELPER(set_cp_reg
)(CPUARMState
*env
, void *rip
, uint32_t value
)
317 const ARMCPRegInfo
*ri
= rip
;
319 ri
->writefn(env
, ri
, value
);
322 uint32_t HELPER(get_cp_reg
)(CPUARMState
*env
, void *rip
)
324 const ARMCPRegInfo
*ri
= rip
;
326 return ri
->readfn(env
, ri
);
329 void HELPER(set_cp_reg64
)(CPUARMState
*env
, void *rip
, uint64_t value
)
331 const ARMCPRegInfo
*ri
= rip
;
333 ri
->writefn(env
, ri
, value
);
336 uint64_t HELPER(get_cp_reg64
)(CPUARMState
*env
, void *rip
)
338 const ARMCPRegInfo
*ri
= rip
;
340 return ri
->readfn(env
, ri
);
343 void HELPER(msr_i_pstate
)(CPUARMState
*env
, uint32_t op
, uint32_t imm
)
345 /* MSR_i to update PSTATE. This is OK from EL0 only if UMA is set.
346 * Note that SPSel is never OK from EL0; we rely on handle_msr_i()
347 * to catch that case at translate time.
349 if (arm_current_pl(env
) == 0 && !(env
->cp15
.c1_sys
& SCTLR_UMA
)) {
350 raise_exception(env
, EXCP_UDEF
);
354 case 0x05: /* SPSel */
355 env
->pstate
= deposit32(env
->pstate
, 0, 1, imm
);
357 case 0x1e: /* DAIFSet */
358 env
->daif
|= (imm
<< 6) & PSTATE_DAIF
;
360 case 0x1f: /* DAIFClear */
361 env
->daif
&= ~((imm
<< 6) & PSTATE_DAIF
);
364 g_assert_not_reached();
368 /* ??? Flag setting arithmetic is awkward because we need to do comparisons.
369 The only way to do that in TCG is a conditional branch, which clobbers
370 all our temporaries. For now implement these as helper functions. */
372 /* Similarly for variable shift instructions. */
374 uint32_t HELPER(shl_cc
)(CPUARMState
*env
, uint32_t x
, uint32_t i
)
376 int shift
= i
& 0xff;
383 } else if (shift
!= 0) {
384 env
->CF
= (x
>> (32 - shift
)) & 1;
390 uint32_t HELPER(shr_cc
)(CPUARMState
*env
, uint32_t x
, uint32_t i
)
392 int shift
= i
& 0xff;
395 env
->CF
= (x
>> 31) & 1;
399 } else if (shift
!= 0) {
400 env
->CF
= (x
>> (shift
- 1)) & 1;
406 uint32_t HELPER(sar_cc
)(CPUARMState
*env
, uint32_t x
, uint32_t i
)
408 int shift
= i
& 0xff;
410 env
->CF
= (x
>> 31) & 1;
411 return (int32_t)x
>> 31;
412 } else if (shift
!= 0) {
413 env
->CF
= (x
>> (shift
- 1)) & 1;
414 return (int32_t)x
>> shift
;
419 uint32_t HELPER(ror_cc
)(CPUARMState
*env
, uint32_t x
, uint32_t i
)
423 shift
= shift1
& 0x1f;
426 env
->CF
= (x
>> 31) & 1;
429 env
->CF
= (x
>> (shift
- 1)) & 1;
430 return ((uint32_t)x
>> shift
) | (x
<< (32 - shift
));