Commit 158142c2 authored by Fabrice Bellard's avatar Fabrice Bellard
Browse files

soft float support 


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@1332 c046a42c-6fe2-441c-8c8c-71466251a162
parent 4f716dc6

Makefile.target

+11 −3
Original line number Diff line number Diff line
@@ -229,7 +229,7 @@ ifeq ($(TARGET_ARCH), i386) 
OBJS+= vm86.o

endif

ifeq ($(TARGET_ARCH), arm)

OBJS+=nwfpe/softfloat.o nwfpe/fpa11.o nwfpe/fpa11_cpdo.o \

OBJS+=nwfpe/fpa11.o nwfpe/fpa11_cpdo.o \

nwfpe/fpa11_cpdt.o nwfpe/fpa11_cprt.o nwfpe/fpopcode.o nwfpe/single_cpdo.o \

 nwfpe/double_cpdo.o nwfpe/extended_cpdo.o

endif
@@ -237,8 +237,14 @@ SRCS:= $(OBJS:.o=.c) 
OBJS+= libqemu.a



# cpu emulator library

LIBOBJS=exec.o kqemu.o translate-all.o cpu-exec.o\

LIBOBJS=exec.o kqemu.o translate-op.o translate-all.o cpu-exec.o\

        translate.o op.o 

ifdef CONFIG_SOFTFLOAT

LIBOBJS+=fpu/softfloat.o

else

LIBOBJS+=fpu/softfloat-native.o

endif

DEFINES+=-I$(SRC_PATH)/fpu



ifeq ($(TARGET_ARCH), i386)

LIBOBJS+=helper.o helper2.o
@@ -399,7 +405,9 @@ libqemu.a: $(LIBOBJS) 


translate.o: translate.c gen-op.h opc.h cpu.h



translate-all.o: translate-all.c op.h opc.h cpu.h

translate-all.o: translate-all.c opc.h cpu.h



translate-op.o: translate-all.c op.h opc.h cpu.h



op.h: op.o $(DYNGEN)

	$(DYNGEN) -o $@ $<

configure

+5 −0
Original line number Diff line number Diff line
@@ -593,6 +593,7 @@ fi 
#echo "Creating $config_mak, $config_h and $target_dir/Makefile"



mkdir -p $target_dir

mkdir -p $target_dir/fpu

if test "$target" = "arm-user" -o "$target" = "armeb-user" ; then

  mkdir -p $target_dir/nwfpe

fi
@@ -658,6 +659,10 @@ if test "$target_user_only" = "yes" ; then 
  echo "#define CONFIG_USER_ONLY 1" >> $config_h

fi



if test "$target_cpu" = "arm" -o "$target_cpu" = "armeb" ; then

  echo "CONFIG_SOFTFLOAT=yes" >> $config_mak

  echo "#define CONFIG_SOFTFLOAT 1" >> $config_h

fi

# sdl defines



if test "$target_user_only" = "no"; then

fpu/softfloat-macros.h

0 → 100644
+720 −0

File added.

Preview size limit exceeded, changes collapsed.

fpu/softfloat-native.c

0 → 100644
+262 −0
Original line number Diff line number Diff line 
/* Native implementation of soft float functions. Only a single status

   context is supported */

#include "softfloat.h"

#include <math.h>



void set_float_rounding_mode(int val STATUS_PARAM)

{

    STATUS(float_rounding_mode) = val;

#if defined(_BSD) && !defined(__APPLE__)

    fpsetround(val);

#elif defined(__arm__)

    /* nothing to do */

#else

    fesetround(val);

#endif

}



#ifdef FLOATX80

void set_floatx80_rounding_precision(int val STATUS_PARAM)

{

    STATUS(floatx80_rounding_precision) = val;

}

#endif



#if defined(_BSD)

#define lrint(d)		((int32_t)rint(d))

#define llrint(d)		((int64_t)rint(d))

#endif



#if defined(__powerpc__)



/* correct (but slow) PowerPC rint() (glibc version is incorrect) */

double qemu_rint(double x)

{

    double y = 4503599627370496.0;

    if (fabs(x) >= y)

        return x;

    if (x < 0) 

        y = -y;

    y = (x + y) - y;

    if (y == 0.0)

        y = copysign(y, x);

    return y;

}



#define rint qemu_rint

#endif



/*----------------------------------------------------------------------------

| Software IEC/IEEE integer-to-floating-point conversion routines.

*----------------------------------------------------------------------------*/

float32 int32_to_float32(int v STATUS_PARAM)

{

    return (float32)v;

}



float64 int32_to_float64(int v STATUS_PARAM)

{

    return (float64)v;

}



#ifdef FLOATX80

floatx80 int32_to_floatx80(int v STATUS_PARAM)

{

    return (floatx80)v;

}

#endif

float32 int64_to_float32( int64_t v STATUS_PARAM)

{

    return (float32)v;

}

float64 int64_to_float64( int64_t v STATUS_PARAM)

{

    return (float64)v;

}

#ifdef FLOATX80

floatx80 int64_to_floatx80( int64_t v STATUS_PARAM)

{

    return (floatx80)v;

}

#endif



/*----------------------------------------------------------------------------

| Software IEC/IEEE single-precision conversion routines.

*----------------------------------------------------------------------------*/

int float32_to_int32( float32 a STATUS_PARAM)

{

    return lrintf(a);

}

int float32_to_int32_round_to_zero( float32 a STATUS_PARAM)

{

    return (int)a;

}

int64_t float32_to_int64( float32 a STATUS_PARAM)

{

    return llrintf(a);

}



int64_t float32_to_int64_round_to_zero( float32 a STATUS_PARAM)

{

    return (int64_t)a;

}



float64 float32_to_float64( float32 a STATUS_PARAM)

{

    return a;

}

#ifdef FLOATX80

floatx80 float32_to_floatx80( float32 a STATUS_PARAM)

{

    return a;

}

#endif



/*----------------------------------------------------------------------------

| Software IEC/IEEE single-precision operations.

*----------------------------------------------------------------------------*/

float32 float32_round_to_int( float32 a STATUS_PARAM)

{

    return rintf(a);

}



float32 float32_sqrt( float32 a STATUS_PARAM)

{

    return sqrtf(a);

}

char float32_is_signaling_nan( float32 a1)

{

    float32u u;

    uint32_t a;

    u.f = a1;

    a = u.i;

    return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );

}



/*----------------------------------------------------------------------------

| Software IEC/IEEE double-precision conversion routines.

*----------------------------------------------------------------------------*/

int float64_to_int32( float64 a STATUS_PARAM)

{

    return lrint(a);

}

int float64_to_int32_round_to_zero( float64 a STATUS_PARAM)

{

    return (int)a;

}

int64_t float64_to_int64( float64 a STATUS_PARAM)

{

    return llrint(a);

}

int64_t float64_to_int64_round_to_zero( float64 a STATUS_PARAM)

{

    return (int64_t)a;

}

float32 float64_to_float32( float64 a STATUS_PARAM)

{

    return a;

}

#ifdef FLOATX80

floatx80 float64_to_floatx80( float64 a STATUS_PARAM)

{

    return a;

}

#endif

#ifdef FLOAT128

float128 float64_to_float128( float64 a STATUS_PARAM)

{

    return a;

}

#endif



/*----------------------------------------------------------------------------

| Software IEC/IEEE double-precision operations.

*----------------------------------------------------------------------------*/

float64 float64_round_to_int( float64 a STATUS_PARAM )

{

#if defined(__arm__)

    switch(STATUS(float_rounding_mode)) {

    default:

    case float_round_nearest_even:

        asm("rndd %0, %1" : "=f" (a) : "f"(a));

        break;

    case float_round_down:

        asm("rnddm %0, %1" : "=f" (a) : "f"(a));

        break;

    case float_round_up:

        asm("rnddp %0, %1" : "=f" (a) : "f"(a));

        break;

    case float_round_to_zero:

        asm("rnddz %0, %1" : "=f" (a) : "f"(a));

        break;

    }

#else

    return rint(a);

#endif

}



float64 float64_sqrt( float64 a STATUS_PARAM)

{

    return sqrt(a);

}

char float64_is_signaling_nan( float64 a1)

{

    float64u u;

    uint64_t a;

    u.f = a1;

    a = u.i;

    return

           ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )

        && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );



}



#ifdef FLOATX80



/*----------------------------------------------------------------------------

| Software IEC/IEEE extended double-precision conversion routines.

*----------------------------------------------------------------------------*/

int floatx80_to_int32( floatx80 a STATUS_PARAM)

{

    return lrintl(a);

}

int floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM)

{

    return (int)a;

}

int64_t floatx80_to_int64( floatx80 a STATUS_PARAM)

{

    return llrintl(a);

}

int64_t floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM)

{

    return (int64_t)a;

}

float32 floatx80_to_float32( floatx80 a STATUS_PARAM)

{

    return a;

}

float64 floatx80_to_float64( floatx80 a STATUS_PARAM)

{

    return a;

}



/*----------------------------------------------------------------------------

| Software IEC/IEEE extended double-precision operations.

*----------------------------------------------------------------------------*/

floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM)

{

    return rintl(a);

}

floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM)

{

    return sqrtl(a);

}

char floatx80_is_signaling_nan( floatx80 a1)

{

    floatx80u u;

    u.f = a1;

    return ( ( u.i.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( u.i.low<<1 );

}



#endif

fpu/softfloat-native.h

0 → 100644
+312 −0
Original line number Diff line number Diff line 
/* Native implementation of soft float functions */

#include <math.h>

#if defined(_BSD) && !defined(__APPLE__)

#include <ieeefp.h>

#else

#include <fenv.h>

#endif



typedef float float32;

typedef double float64;

#ifdef FLOATX80

typedef long double floatx80;

#endif



typedef union {

    float32 f;

    uint32_t i;

} float32u;

typedef union {

    float64 f;

    uint64_t i;

} float64u;

#ifdef FLOATX80

typedef union {

    floatx80 f;

    struct {

        uint64_t low;

        uint16_t high;

    } i;

} floatx80u;

#endif



/*----------------------------------------------------------------------------

| Software IEC/IEEE floating-point rounding mode.

*----------------------------------------------------------------------------*/

#if defined(_BSD) && !defined(__APPLE__)

enum {

    float_round_nearest_even = FP_RN,

    float_round_down         = FE_RM,

    float_round_up           = FE_RP,

    float_round_to_zero      = FE_RZ

};

#elif defined(__arm__)

enum {

    float_round_nearest_even = 0,

    float_round_down         = 1,

    float_round_up           = 2,

    float_round_to_zero      = 3

};

#else

enum {

    float_round_nearest_even = FE_TONEAREST,

    float_round_down         = FE_DOWNWARD,

    float_round_up           = FE_UPWARD,

    float_round_to_zero      = FE_TOWARDZERO

};

#endif



typedef struct float_status {

    signed char float_rounding_mode;

#ifdef FLOATX80

    signed char floatx80_rounding_precision;

#endif

} float_status;



void set_float_rounding_mode(int val STATUS_PARAM);

#ifdef FLOATX80

void set_floatx80_rounding_precision(int val STATUS_PARAM);

#endif



/*----------------------------------------------------------------------------

| Software IEC/IEEE integer-to-floating-point conversion routines.

*----------------------------------------------------------------------------*/

float32 int32_to_float32( int STATUS_PARAM);

float64 int32_to_float64( int STATUS_PARAM);

#ifdef FLOATX80

floatx80 int32_to_floatx80( int STATUS_PARAM);

#endif

#ifdef FLOAT128

float128 int32_to_float128( int STATUS_PARAM);

#endif

float32 int64_to_float32( int64_t STATUS_PARAM);

float64 int64_to_float64( int64_t STATUS_PARAM);

#ifdef FLOATX80

floatx80 int64_to_floatx80( int64_t STATUS_PARAM);

#endif

#ifdef FLOAT128

float128 int64_to_float128( int64_t STATUS_PARAM);

#endif



/*----------------------------------------------------------------------------

| Software IEC/IEEE single-precision conversion routines.

*----------------------------------------------------------------------------*/

int float32_to_int32( float32  STATUS_PARAM);

int float32_to_int32_round_to_zero( float32  STATUS_PARAM);

int64_t float32_to_int64( float32  STATUS_PARAM);

int64_t float32_to_int64_round_to_zero( float32  STATUS_PARAM);

float64 float32_to_float64( float32  STATUS_PARAM);

#ifdef FLOATX80

floatx80 float32_to_floatx80( float32  STATUS_PARAM);

#endif

#ifdef FLOAT128

float128 float32_to_float128( float32  STATUS_PARAM);

#endif



/*----------------------------------------------------------------------------

| Software IEC/IEEE single-precision operations.

*----------------------------------------------------------------------------*/

float32 float32_round_to_int( float32  STATUS_PARAM);

INLINE float32 float32_add( float32 a, float32 b STATUS_PARAM)

{

    return a + b;

}

INLINE float32 float32_sub( float32 a, float32 b STATUS_PARAM)

{

    return a - b;

}

INLINE float32 float32_mul( float32 a, float32 b STATUS_PARAM)

{

    return a * b;

}

INLINE float32 float32_div( float32 a, float32 b STATUS_PARAM)

{

    return a / b;

}

float32 float32_rem( float32, float32  STATUS_PARAM);

float32 float32_sqrt( float32  STATUS_PARAM);

INLINE char float32_eq( float32 a, float32 b STATUS_PARAM)

{

    /* XXX: incorrect because it can raise an exception */

    return a == b;

}

INLINE char float32_le( float32 a, float32 b STATUS_PARAM)

{

    return a <= b;

}

INLINE char float32_lt( float32 a, float32 b STATUS_PARAM)

{

    return a < b;

}

INLINE char float32_eq_signaling( float32 a, float32 b STATUS_PARAM)

{

    return a == b;

}

INLINE char float32_le_quiet( float32 a, float32 b STATUS_PARAM)

{

    return islessequal(a, b);

}

INLINE char float32_lt_quiet( float32 a, float32 b STATUS_PARAM)

{

    return isless(a, b);

}

char float32_is_signaling_nan( float32 );



INLINE float32 float32_abs(float32 a)

{

    return fabsf(a);

}



INLINE float32 float32_chs(float32 a)

{

    return -a;

}



/*----------------------------------------------------------------------------

| Software IEC/IEEE double-precision conversion routines.

*----------------------------------------------------------------------------*/

int float64_to_int32( float64 STATUS_PARAM );

int float64_to_int32_round_to_zero( float64 STATUS_PARAM );

int64_t float64_to_int64( float64 STATUS_PARAM );

int64_t float64_to_int64_round_to_zero( float64 STATUS_PARAM );

float32 float64_to_float32( float64 STATUS_PARAM );

#ifdef FLOATX80

floatx80 float64_to_floatx80( float64 STATUS_PARAM );

#endif

#ifdef FLOAT128

float128 float64_to_float128( float64 STATUS_PARAM );

#endif



/*----------------------------------------------------------------------------

| Software IEC/IEEE double-precision operations.

*----------------------------------------------------------------------------*/

float64 float64_round_to_int( float64 STATUS_PARAM );

INLINE float64 float64_add( float64 a, float64 b STATUS_PARAM)

{

    return a + b;

}

INLINE float64 float64_sub( float64 a, float64 b STATUS_PARAM)

{

    return a - b;

}

INLINE float64 float64_mul( float64 a, float64 b STATUS_PARAM)

{

    return a * b;

}

INLINE float64 float64_div( float64 a, float64 b STATUS_PARAM)

{

    return a / b;

}

float64 float64_rem( float64, float64 STATUS_PARAM );

float64 float64_sqrt( float64 STATUS_PARAM );

INLINE char float64_eq( float64 a, float64 b STATUS_PARAM)

{

    return a == b;

}

INLINE char float64_le( float64 a, float64 b STATUS_PARAM)

{

    return a <= b;

}

INLINE char float64_lt( float64 a, float64 b STATUS_PARAM)

{

    return a < b;

}

INLINE char float64_eq_signaling( float64 a, float64 b STATUS_PARAM)

{

    return a == b;

}

INLINE char float64_le_quiet( float64 a, float64 b STATUS_PARAM)

{

    return islessequal(a, b);

}

INLINE char float64_lt_quiet( float64 a, float64 b STATUS_PARAM)

{

    return isless(a, b);



}

char float64_is_signaling_nan( float64 );



INLINE float64 float64_abs(float64 a)

{

    return fabs(a);

}



INLINE float64 float64_chs(float64 a)

{

    return -a;

}



#ifdef FLOATX80



/*----------------------------------------------------------------------------

| Software IEC/IEEE extended double-precision conversion routines.

*----------------------------------------------------------------------------*/

int floatx80_to_int32( floatx80 STATUS_PARAM );

int floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM );

int64_t floatx80_to_int64( floatx80 STATUS_PARAM);

int64_t floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM);

float32 floatx80_to_float32( floatx80 STATUS_PARAM );

float64 floatx80_to_float64( floatx80 STATUS_PARAM );

#ifdef FLOAT128

float128 floatx80_to_float128( floatx80 STATUS_PARAM );

#endif



/*----------------------------------------------------------------------------

| Software IEC/IEEE extended double-precision operations.

*----------------------------------------------------------------------------*/

floatx80 floatx80_round_to_int( floatx80 STATUS_PARAM );

INLINE floatx80 floatx80_add( floatx80 a, floatx80 b STATUS_PARAM)

{

    return a + b;

}

INLINE floatx80 floatx80_sub( floatx80 a, floatx80 b STATUS_PARAM)

{

    return a - b;

}

INLINE floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM)

{

    return a * b;

}

INLINE floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM)

{

    return a / b;

}

floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM );

floatx80 floatx80_sqrt( floatx80 STATUS_PARAM );

INLINE char floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM)

{

    return a == b;

}

INLINE char floatx80_le( floatx80 a, floatx80 b STATUS_PARAM)

{

    return a <= b;

}

INLINE char floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM)

{

    return a < b;

}

INLINE char floatx80_eq_signaling( floatx80 a, floatx80 b STATUS_PARAM)

{

    return a == b;

}

INLINE char floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM)

{

    return islessequal(a, b);

}

INLINE char floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM)

{

    return isless(a, b);



}

char floatx80_is_signaling_nan( floatx80 );



INLINE floatx80 floatx80_abs(floatx80 a)

{

    return fabsl(a);

}



INLINE floatx80 floatx80_chs(floatx80 a)

{

    return -a;

}

#endif