Revision 636aa200 target-ppc/op_helper.c
| b/target-ppc/op_helper.c | ||
|---|---|---|
| 239 | 239 |
/*****************************************************************************/ |
| 240 | 240 |
/* Memory load and stores */ |
| 241 | 241 |
|
| 242 |
static always_inline target_ulong addr_add(target_ulong addr, target_long arg)
|
|
| 242 |
static inline target_ulong addr_add(target_ulong addr, target_long arg) |
|
| 243 | 243 |
{
|
| 244 | 244 |
#if defined(TARGET_PPC64) |
| 245 | 245 |
if (!msr_sf) |
| ... | ... | |
| 532 | 532 |
return f.l; |
| 533 | 533 |
} |
| 534 | 534 |
|
| 535 |
static always_inline int isden (float64 d)
|
|
| 535 |
static inline int isden(float64 d)
|
|
| 536 | 536 |
{
|
| 537 | 537 |
CPU_DoubleU u; |
| 538 | 538 |
|
| ... | ... | |
| 594 | 594 |
} |
| 595 | 595 |
|
| 596 | 596 |
/* Floating-point invalid operations exception */ |
| 597 |
static always_inline uint64_t fload_invalid_op_excp (int op)
|
|
| 597 |
static inline uint64_t fload_invalid_op_excp(int op)
|
|
| 598 | 598 |
{
|
| 599 | 599 |
uint64_t ret = 0; |
| 600 | 600 |
int ve; |
| ... | ... | |
| 675 | 675 |
return ret; |
| 676 | 676 |
} |
| 677 | 677 |
|
| 678 |
static always_inline void float_zero_divide_excp (void)
|
|
| 678 |
static inline void float_zero_divide_excp(void)
|
|
| 679 | 679 |
{
|
| 680 | 680 |
env->fpscr |= 1 << FPSCR_ZX; |
| 681 | 681 |
env->fpscr &= ~((1 << FPSCR_FR) | (1 << FPSCR_FI)); |
| ... | ... | |
| 691 | 691 |
} |
| 692 | 692 |
} |
| 693 | 693 |
|
| 694 |
static always_inline void float_overflow_excp (void)
|
|
| 694 |
static inline void float_overflow_excp(void)
|
|
| 695 | 695 |
{
|
| 696 | 696 |
env->fpscr |= 1 << FPSCR_OX; |
| 697 | 697 |
/* Update the floating-point exception summary */ |
| ... | ... | |
| 709 | 709 |
} |
| 710 | 710 |
} |
| 711 | 711 |
|
| 712 |
static always_inline void float_underflow_excp (void)
|
|
| 712 |
static inline void float_underflow_excp(void)
|
|
| 713 | 713 |
{
|
| 714 | 714 |
env->fpscr |= 1 << FPSCR_UX; |
| 715 | 715 |
/* Update the floating-point exception summary */ |
| ... | ... | |
| 724 | 724 |
} |
| 725 | 725 |
} |
| 726 | 726 |
|
| 727 |
static always_inline void float_inexact_excp (void)
|
|
| 727 |
static inline void float_inexact_excp(void)
|
|
| 728 | 728 |
{
|
| 729 | 729 |
env->fpscr |= 1 << FPSCR_XX; |
| 730 | 730 |
/* Update the floating-point exception summary */ |
| ... | ... | |
| 738 | 738 |
} |
| 739 | 739 |
} |
| 740 | 740 |
|
| 741 |
static always_inline void fpscr_set_rounding_mode (void)
|
|
| 741 |
static inline void fpscr_set_rounding_mode(void)
|
|
| 742 | 742 |
{
|
| 743 | 743 |
int rnd_type; |
| 744 | 744 |
|
| ... | ... | |
| 1199 | 1199 |
|
| 1200 | 1200 |
#endif |
| 1201 | 1201 |
|
| 1202 |
static always_inline uint64_t do_fri (uint64_t arg, int rounding_mode)
|
|
| 1202 |
static inline uint64_t do_fri(uint64_t arg, int rounding_mode)
|
|
| 1203 | 1203 |
{
|
| 1204 | 1204 |
CPU_DoubleU farg; |
| 1205 | 1205 |
farg.ll = arg; |
| ... | ... | |
| 1614 | 1614 |
} |
| 1615 | 1615 |
} |
| 1616 | 1616 |
|
| 1617 |
static always_inline void do_rfi (target_ulong nip, target_ulong msr,
|
|
| 1618 |
target_ulong msrm, int keep_msrh)
|
|
| 1617 |
static inline void do_rfi(target_ulong nip, target_ulong msr,
|
|
| 1618 |
target_ulong msrm, int keep_msrh) |
|
| 1619 | 1619 |
{
|
| 1620 | 1620 |
#if defined(TARGET_PPC64) |
| 1621 | 1621 |
if (msr & (1ULL << MSR_SF)) {
|
| ... | ... | |
| 1956 | 1956 |
|
| 1957 | 1957 |
/* Saturating arithmetic helpers. */ |
| 1958 | 1958 |
#define SATCVT(from, to, from_type, to_type, min, max, use_min, use_max) \ |
| 1959 |
static always_inline to_type cvt##from##to (from_type x, int *sat) \
|
|
| 1959 |
static inline to_type cvt##from##to(from_type x, int *sat) \
|
|
| 1960 | 1960 |
{ \
|
| 1961 | 1961 |
to_type r; \ |
| 1962 | 1962 |
if (use_min && x < min) { \
|
| ... | ... | |
| 1975 | 1975 |
SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX, 1, 1) |
| 1976 | 1976 |
|
| 1977 | 1977 |
/* Work around gcc problems with the macro version */ |
| 1978 |
static always_inline uint8_t cvtuhub(uint16_t x, int *sat)
|
|
| 1978 |
static inline uint8_t cvtuhub(uint16_t x, int *sat) |
|
| 1979 | 1979 |
{
|
| 1980 | 1980 |
uint8_t r; |
| 1981 | 1981 |
|
| ... | ... | |
| 2243 | 2243 |
#undef VCMPFP_DO |
| 2244 | 2244 |
#undef VCMPFP |
| 2245 | 2245 |
|
| 2246 |
static always_inline void vcmpbfp_internal (ppc_avr_t *r, ppc_avr_t *a,
|
|
| 2247 |
ppc_avr_t *b, int record)
|
|
| 2246 |
static inline void vcmpbfp_internal(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b,
|
|
| 2247 |
int record) |
|
| 2248 | 2248 |
{
|
| 2249 | 2249 |
int i; |
| 2250 | 2250 |
int all_in = 0; |
| ... | ... | |
| 3063 | 3063 |
0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF, |
| 3064 | 3064 |
}; |
| 3065 | 3065 |
|
| 3066 |
static always_inline uint8_t byte_reverse (uint8_t val)
|
|
| 3066 |
static inline uint8_t byte_reverse(uint8_t val)
|
|
| 3067 | 3067 |
{
|
| 3068 | 3068 |
return hbrev[val >> 4] | (hbrev[val & 0xF] << 4); |
| 3069 | 3069 |
} |
| 3070 | 3070 |
|
| 3071 |
static always_inline uint32_t word_reverse (uint32_t val)
|
|
| 3071 |
static inline uint32_t word_reverse(uint32_t val)
|
|
| 3072 | 3072 |
{
|
| 3073 | 3073 |
return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) | |
| 3074 | 3074 |
(byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24); |
| ... | ... | |
| 3100 | 3100 |
} |
| 3101 | 3101 |
|
| 3102 | 3102 |
/* Single-precision floating-point conversions */ |
| 3103 |
static always_inline uint32_t efscfsi (uint32_t val)
|
|
| 3103 |
static inline uint32_t efscfsi(uint32_t val)
|
|
| 3104 | 3104 |
{
|
| 3105 | 3105 |
CPU_FloatU u; |
| 3106 | 3106 |
|
| ... | ... | |
| 3109 | 3109 |
return u.l; |
| 3110 | 3110 |
} |
| 3111 | 3111 |
|
| 3112 |
static always_inline uint32_t efscfui (uint32_t val)
|
|
| 3112 |
static inline uint32_t efscfui(uint32_t val)
|
|
| 3113 | 3113 |
{
|
| 3114 | 3114 |
CPU_FloatU u; |
| 3115 | 3115 |
|
| ... | ... | |
| 3118 | 3118 |
return u.l; |
| 3119 | 3119 |
} |
| 3120 | 3120 |
|
| 3121 |
static always_inline int32_t efsctsi (uint32_t val)
|
|
| 3121 |
static inline int32_t efsctsi(uint32_t val)
|
|
| 3122 | 3122 |
{
|
| 3123 | 3123 |
CPU_FloatU u; |
| 3124 | 3124 |
|
| ... | ... | |
| 3130 | 3130 |
return float32_to_int32(u.f, &env->vec_status); |
| 3131 | 3131 |
} |
| 3132 | 3132 |
|
| 3133 |
static always_inline uint32_t efsctui (uint32_t val)
|
|
| 3133 |
static inline uint32_t efsctui(uint32_t val)
|
|
| 3134 | 3134 |
{
|
| 3135 | 3135 |
CPU_FloatU u; |
| 3136 | 3136 |
|
| ... | ... | |
| 3142 | 3142 |
return float32_to_uint32(u.f, &env->vec_status); |
| 3143 | 3143 |
} |
| 3144 | 3144 |
|
| 3145 |
static always_inline uint32_t efsctsiz (uint32_t val)
|
|
| 3145 |
static inline uint32_t efsctsiz(uint32_t val)
|
|
| 3146 | 3146 |
{
|
| 3147 | 3147 |
CPU_FloatU u; |
| 3148 | 3148 |
|
| ... | ... | |
| 3154 | 3154 |
return float32_to_int32_round_to_zero(u.f, &env->vec_status); |
| 3155 | 3155 |
} |
| 3156 | 3156 |
|
| 3157 |
static always_inline uint32_t efsctuiz (uint32_t val)
|
|
| 3157 |
static inline uint32_t efsctuiz(uint32_t val)
|
|
| 3158 | 3158 |
{
|
| 3159 | 3159 |
CPU_FloatU u; |
| 3160 | 3160 |
|
| ... | ... | |
| 3166 | 3166 |
return float32_to_uint32_round_to_zero(u.f, &env->vec_status); |
| 3167 | 3167 |
} |
| 3168 | 3168 |
|
| 3169 |
static always_inline uint32_t efscfsf (uint32_t val)
|
|
| 3169 |
static inline uint32_t efscfsf(uint32_t val)
|
|
| 3170 | 3170 |
{
|
| 3171 | 3171 |
CPU_FloatU u; |
| 3172 | 3172 |
float32 tmp; |
| ... | ... | |
| 3178 | 3178 |
return u.l; |
| 3179 | 3179 |
} |
| 3180 | 3180 |
|
| 3181 |
static always_inline uint32_t efscfuf (uint32_t val)
|
|
| 3181 |
static inline uint32_t efscfuf(uint32_t val)
|
|
| 3182 | 3182 |
{
|
| 3183 | 3183 |
CPU_FloatU u; |
| 3184 | 3184 |
float32 tmp; |
| ... | ... | |
| 3190 | 3190 |
return u.l; |
| 3191 | 3191 |
} |
| 3192 | 3192 |
|
| 3193 |
static always_inline uint32_t efsctsf (uint32_t val)
|
|
| 3193 |
static inline uint32_t efsctsf(uint32_t val)
|
|
| 3194 | 3194 |
{
|
| 3195 | 3195 |
CPU_FloatU u; |
| 3196 | 3196 |
float32 tmp; |
| ... | ... | |
| 3205 | 3205 |
return float32_to_int32(u.f, &env->vec_status); |
| 3206 | 3206 |
} |
| 3207 | 3207 |
|
| 3208 |
static always_inline uint32_t efsctuf (uint32_t val)
|
|
| 3208 |
static inline uint32_t efsctuf(uint32_t val)
|
|
| 3209 | 3209 |
{
|
| 3210 | 3210 |
CPU_FloatU u; |
| 3211 | 3211 |
float32 tmp; |
| ... | ... | |
| 3274 | 3274 |
HELPER_SPE_VECTOR_CONV(fsctuf); |
| 3275 | 3275 |
|
| 3276 | 3276 |
/* Single-precision floating-point arithmetic */ |
| 3277 |
static always_inline uint32_t efsadd (uint32_t op1, uint32_t op2)
|
|
| 3277 |
static inline uint32_t efsadd(uint32_t op1, uint32_t op2)
|
|
| 3278 | 3278 |
{
|
| 3279 | 3279 |
CPU_FloatU u1, u2; |
| 3280 | 3280 |
u1.l = op1; |
| ... | ... | |
| 3283 | 3283 |
return u1.l; |
| 3284 | 3284 |
} |
| 3285 | 3285 |
|
| 3286 |
static always_inline uint32_t efssub (uint32_t op1, uint32_t op2)
|
|
| 3286 |
static inline uint32_t efssub(uint32_t op1, uint32_t op2)
|
|
| 3287 | 3287 |
{
|
| 3288 | 3288 |
CPU_FloatU u1, u2; |
| 3289 | 3289 |
u1.l = op1; |
| ... | ... | |
| 3292 | 3292 |
return u1.l; |
| 3293 | 3293 |
} |
| 3294 | 3294 |
|
| 3295 |
static always_inline uint32_t efsmul (uint32_t op1, uint32_t op2)
|
|
| 3295 |
static inline uint32_t efsmul(uint32_t op1, uint32_t op2)
|
|
| 3296 | 3296 |
{
|
| 3297 | 3297 |
CPU_FloatU u1, u2; |
| 3298 | 3298 |
u1.l = op1; |
| ... | ... | |
| 3301 | 3301 |
return u1.l; |
| 3302 | 3302 |
} |
| 3303 | 3303 |
|
| 3304 |
static always_inline uint32_t efsdiv (uint32_t op1, uint32_t op2)
|
|
| 3304 |
static inline uint32_t efsdiv(uint32_t op1, uint32_t op2)
|
|
| 3305 | 3305 |
{
|
| 3306 | 3306 |
CPU_FloatU u1, u2; |
| 3307 | 3307 |
u1.l = op1; |
| ... | ... | |
| 3340 | 3340 |
HELPER_SPE_VECTOR_ARITH(fsdiv); |
| 3341 | 3341 |
|
| 3342 | 3342 |
/* Single-precision floating-point comparisons */ |
| 3343 |
static always_inline uint32_t efststlt (uint32_t op1, uint32_t op2)
|
|
| 3343 |
static inline uint32_t efststlt(uint32_t op1, uint32_t op2)
|
|
| 3344 | 3344 |
{
|
| 3345 | 3345 |
CPU_FloatU u1, u2; |
| 3346 | 3346 |
u1.l = op1; |
| ... | ... | |
| 3348 | 3348 |
return float32_lt(u1.f, u2.f, &env->vec_status) ? 4 : 0; |
| 3349 | 3349 |
} |
| 3350 | 3350 |
|
| 3351 |
static always_inline uint32_t efststgt (uint32_t op1, uint32_t op2)
|
|
| 3351 |
static inline uint32_t efststgt(uint32_t op1, uint32_t op2)
|
|
| 3352 | 3352 |
{
|
| 3353 | 3353 |
CPU_FloatU u1, u2; |
| 3354 | 3354 |
u1.l = op1; |
| ... | ... | |
| 3356 | 3356 |
return float32_le(u1.f, u2.f, &env->vec_status) ? 0 : 4; |
| 3357 | 3357 |
} |
| 3358 | 3358 |
|
| 3359 |
static always_inline uint32_t efststeq (uint32_t op1, uint32_t op2)
|
|
| 3359 |
static inline uint32_t efststeq(uint32_t op1, uint32_t op2)
|
|
| 3360 | 3360 |
{
|
| 3361 | 3361 |
CPU_FloatU u1, u2; |
| 3362 | 3362 |
u1.l = op1; |
| ... | ... | |
| 3364 | 3364 |
return float32_eq(u1.f, u2.f, &env->vec_status) ? 4 : 0; |
| 3365 | 3365 |
} |
| 3366 | 3366 |
|
| 3367 |
static always_inline uint32_t efscmplt (uint32_t op1, uint32_t op2)
|
|
| 3367 |
static inline uint32_t efscmplt(uint32_t op1, uint32_t op2)
|
|
| 3368 | 3368 |
{
|
| 3369 | 3369 |
/* XXX: TODO: test special values (NaN, infinites, ...) */ |
| 3370 | 3370 |
return efststlt(op1, op2); |
| 3371 | 3371 |
} |
| 3372 | 3372 |
|
| 3373 |
static always_inline uint32_t efscmpgt (uint32_t op1, uint32_t op2)
|
|
| 3373 |
static inline uint32_t efscmpgt(uint32_t op1, uint32_t op2)
|
|
| 3374 | 3374 |
{
|
| 3375 | 3375 |
/* XXX: TODO: test special values (NaN, infinites, ...) */ |
| 3376 | 3376 |
return efststgt(op1, op2); |
| 3377 | 3377 |
} |
| 3378 | 3378 |
|
| 3379 |
static always_inline uint32_t efscmpeq (uint32_t op1, uint32_t op2)
|
|
| 3379 |
static inline uint32_t efscmpeq(uint32_t op1, uint32_t op2)
|
|
| 3380 | 3380 |
{
|
| 3381 | 3381 |
/* XXX: TODO: test special values (NaN, infinites, ...) */ |
| 3382 | 3382 |
return efststeq(op1, op2); |
| ... | ... | |
| 3400 | 3400 |
/* efscmpeq */ |
| 3401 | 3401 |
HELPER_SINGLE_SPE_CMP(fscmpeq); |
| 3402 | 3402 |
|
| 3403 |
static always_inline uint32_t evcmp_merge (int t0, int t1)
|
|
| 3403 |
static inline uint32_t evcmp_merge(int t0, int t1)
|
|
| 3404 | 3404 |
{
|
| 3405 | 3405 |
return (t0 << 3) | (t1 << 2) | ((t0 | t1) << 1) | (t0 & t1); |
| 3406 | 3406 |
} |
| ... | ... | |
| 3850 | 3850 |
do_74xx_tlb(EPN, 1); |
| 3851 | 3851 |
} |
| 3852 | 3852 |
|
| 3853 |
static always_inline target_ulong booke_tlb_to_page_size (int size)
|
|
| 3853 |
static inline target_ulong booke_tlb_to_page_size(int size)
|
|
| 3854 | 3854 |
{
|
| 3855 | 3855 |
return 1024 << (2 * size); |
| 3856 | 3856 |
} |
| 3857 | 3857 |
|
| 3858 |
static always_inline int booke_page_size_to_tlb (target_ulong page_size)
|
|
| 3858 |
static inline int booke_page_size_to_tlb(target_ulong page_size)
|
|
| 3859 | 3859 |
{
|
| 3860 | 3860 |
int size; |
| 3861 | 3861 |
|
Also available in: Unified diff