Revision 5500b06c targetarm/helper.c
b/targetarm/helper.c  

2526  2526 
DO_VFP_cmp(d, float64) 
2527  2527 
#undef DO_VFP_cmp 
2528  2528  
2529 
/* Integer to float conversion. */ 

2530 
float32 VFP_HELPER(uito, s)(uint32_t x, CPUState *env) 

2531 
{ 

2532 
return uint32_to_float32(x, &env>vfp.fp_status); 

2533 
} 

2529 
/* Integer to float and float to integer conversions */ 

2534  2530  
2535 
float64 VFP_HELPER(uito, d)(uint32_t x, CPUState *env) 

2536 
{ 

2537 
return uint32_to_float64(x, &env>vfp.fp_status); 

2538 
} 

2539  
2540 
float32 VFP_HELPER(sito, s)(uint32_t x, CPUState *env) 

2541 
{ 

2542 
return int32_to_float32(x, &env>vfp.fp_status); 

2543 
} 

2544  
2545 
float64 VFP_HELPER(sito, d)(uint32_t x, CPUState *env) 

2546 
{ 

2547 
return int32_to_float64(x, &env>vfp.fp_status); 

2548 
} 

2549  
2550 
/* Float to integer conversion. */ 

2551 
uint32_t VFP_HELPER(toui, s)(float32 x, CPUState *env) 

2552 
{ 

2553 
if (float32_is_any_nan(x)) { 

2554 
float_raise(float_flag_invalid, &env>vfp.fp_status); 

2555 
return 0; 

2556 
} 

2557 
return float32_to_uint32(x, &env>vfp.fp_status); 

2558 
} 

2559  
2560 
uint32_t VFP_HELPER(toui, d)(float64 x, CPUState *env) 

2561 
{ 

2562 
if (float64_is_any_nan(x)) { 

2563 
float_raise(float_flag_invalid, &env>vfp.fp_status); 

2564 
return 0; 

2565 
} 

2566 
return float64_to_uint32(x, &env>vfp.fp_status); 

2567 
} 

2568  
2569 
uint32_t VFP_HELPER(tosi, s)(float32 x, CPUState *env) 

2570 
{ 

2571 
if (float32_is_any_nan(x)) { 

2572 
float_raise(float_flag_invalid, &env>vfp.fp_status); 

2573 
return 0; 

2574 
} 

2575 
return float32_to_int32(x, &env>vfp.fp_status); 

2576 
} 

2577  
2578 
uint32_t VFP_HELPER(tosi, d)(float64 x, CPUState *env) 

2579 
{ 

2580 
if (float64_is_any_nan(x)) { 

2581 
float_raise(float_flag_invalid, &env>vfp.fp_status); 

2582 
return 0; 

2583 
} 

2584 
return float64_to_int32(x, &env>vfp.fp_status); 

2531 
#define CONV_ITOF(name, fsz, sign) \ 

2532 
float##fsz HELPER(name)(uint32_t x, void *fpstp) \ 

2533 
{ \ 

2534 
float_status *fpst = fpstp; \ 

2535 
return sign##int32_to_##float##fsz(x, fpst); \ 

2585  2536 
} 
2586  2537  
2587 
uint32_t VFP_HELPER(touiz, s)(float32 x, CPUState *env) 

2588 
{ 

2589 
if (float32_is_any_nan(x)) { 

2590 
float_raise(float_flag_invalid, &env>vfp.fp_status); 

2591 
return 0; 

2592 
} 

2593 
return float32_to_uint32_round_to_zero(x, &env>vfp.fp_status); 

2538 
#define CONV_FTOI(name, fsz, sign, round) \ 

2539 
uint32_t HELPER(name)(float##fsz x, void *fpstp) \ 

2540 
{ \ 

2541 
float_status *fpst = fpstp; \ 

2542 
if (float##fsz##_is_any_nan(x)) { \ 

2543 
float_raise(float_flag_invalid, fpst); \ 

2544 
return 0; \ 

2545 
} \ 

2546 
return float##fsz##_to_##sign##int32##round(x, fpst); \ 

2594  2547 
} 
2595  2548  
2596 
uint32_t VFP_HELPER(touiz, d)(float64 x, CPUState *env) 

2597 
{ 

2598 
if (float64_is_any_nan(x)) { 

2599 
float_raise(float_flag_invalid, &env>vfp.fp_status); 

2600 
return 0; 

2601 
} 

2602 
return float64_to_uint32_round_to_zero(x, &env>vfp.fp_status); 

2603 
} 

2549 
#define FLOAT_CONVS(name, p, fsz, sign) \ 

2550 
CONV_ITOF(vfp_##name##to##p, fsz, sign) \ 

2551 
CONV_FTOI(vfp_to##name##p, fsz, sign, ) \ 

2552 
CONV_FTOI(vfp_to##name##z##p, fsz, sign, _round_to_zero) 

2604  2553  
2605 
uint32_t VFP_HELPER(tosiz, s)(float32 x, CPUState *env) 

2606 
{ 

2607 
if (float32_is_any_nan(x)) { 

2608 
float_raise(float_flag_invalid, &env>vfp.fp_status); 

2609 
return 0; 

2610 
} 

2611 
return float32_to_int32_round_to_zero(x, &env>vfp.fp_status); 

2612 
} 

2554 
FLOAT_CONVS(si, s, 32, ) 

2555 
FLOAT_CONVS(si, d, 64, ) 

2556 
FLOAT_CONVS(ui, s, 32, u) 

2557 
FLOAT_CONVS(ui, d, 64, u) 

2613  2558  
2614 
uint32_t VFP_HELPER(tosiz, d)(float64 x, CPUState *env) 

2615 
{ 

2616 
if (float64_is_any_nan(x)) { 

2617 
float_raise(float_flag_invalid, &env>vfp.fp_status); 

2618 
return 0; 

2619 
} 

2620 
return float64_to_int32_round_to_zero(x, &env>vfp.fp_status); 

2621 
} 

2559 
#undef CONV_ITOF 

2560 
#undef CONV_FTOI 

2561 
#undef FLOAT_CONVS 

2622  2562  
2623  2563 
/* floating point conversion */ 
2624  2564 
float64 VFP_HELPER(fcvtd, s)(float32 x, CPUState *env) 
...  ...  
2641  2581  
2642  2582 
/* VFP3 fixed point conversion. */ 
2643  2583 
#define VFP_CONV_FIX(name, p, fsz, itype, sign) \ 
2644 
float##fsz VFP_HELPER(name##to, p)(uint##fsz##_t x, uint32_t shift, \


2645 
CPUState *env) \


2584 
float##fsz HELPER(vfp_##name##to##p)(uint##fsz##_t x, uint32_t shift, \


2585 
void *fpstp) \


2646  2586 
{ \ 
2587 
float_status *fpst = fpstp; \ 

2647  2588 
float##fsz tmp; \ 
2648 
tmp = sign##int32_to_##float##fsz ((itype##_t)x, &env>vfp.fp_status); \


2649 
return float##fsz##_scalbn(tmp, (int)shift, &env>vfp.fp_status); \


2589 
tmp = sign##int32_to_##float##fsz((itype##_t)x, fpst); \


2590 
return float##fsz##_scalbn(tmp, (int)shift, fpst); \


2650  2591 
} \ 
2651 
uint##fsz##_t VFP_HELPER(to##name, p)(float##fsz x, uint32_t shift, \


2652 
CPUState *env) \


2592 
uint##fsz##_t HELPER(vfp_to##name##p)(float##fsz x, uint32_t shift, \


2593 
void *fpstp) \


2653  2594 
{ \ 
2595 
float_status *fpst = fpstp; \ 

2654  2596 
float##fsz tmp; \ 
2655  2597 
if (float##fsz##_is_any_nan(x)) { \ 
2656 
float_raise(float_flag_invalid, &env>vfp.fp_status); \


2598 
float_raise(float_flag_invalid, fpst); \


2657  2599 
return 0; \ 
2658  2600 
} \ 
2659 
tmp = float##fsz##_scalbn(x, shift, &env>vfp.fp_status); \


2660 
return float##fsz##_to_##itype##_round_to_zero(tmp, &env>vfp.fp_status); \


2601 
tmp = float##fsz##_scalbn(x, shift, fpst); \


2602 
return float##fsz##_to_##itype##_round_to_zero(tmp, fpst); \


2661  2603 
} 
2662  2604  
2663  2605 
VFP_CONV_FIX(sh, d, 64, int16, ) 
Also available in: Unified diff