diff --git a/bochs/cpu/softfloat3e/extF80_to_f16.c b/bochs/cpu/softfloat3e/extF80_to_f16.c
index 22a8a914c..23f731120 100644
--- a/bochs/cpu/softfloat3e/extF80_to_f16.c
+++ b/bochs/cpu/softfloat3e/extF80_to_f16.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t extF80_to_f16(extFloat80_t a, struct softfloat_status_t *status)
+float16 extF80_to_f16(extFloat80_t a, struct softfloat_status_t *status)
 {
     uint16_t uiA64;
     uint64_t uiA0;
diff --git a/bochs/cpu/softfloat3e/extF80_to_f32.c b/bochs/cpu/softfloat3e/extF80_to_f32.c
index 8962b9fb1..9217d1800 100644
--- a/bochs/cpu/softfloat3e/extF80_to_f32.c
+++ b/bochs/cpu/softfloat3e/extF80_to_f32.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t extF80_to_f32(extFloat80_t a, struct softfloat_status_t *status)
+float32 extF80_to_f32(extFloat80_t a, struct softfloat_status_t *status)
 {
     uint16_t uiA64;
     uint64_t uiA0;
diff --git a/bochs/cpu/softfloat3e/extF80_to_f64.c b/bochs/cpu/softfloat3e/extF80_to_f64.c
index de16fc2ed..1463c8c10 100644
--- a/bochs/cpu/softfloat3e/extF80_to_f64.c
+++ b/bochs/cpu/softfloat3e/extF80_to_f64.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t extF80_to_f64(extFloat80_t a, struct softfloat_status_t *status)
+float64 extF80_to_f64(extFloat80_t a, struct softfloat_status_t *status)
 {
     uint16_t uiA64;
     uint64_t uiA0;
diff --git a/bochs/cpu/softfloat3e/f128_to_f32.c b/bochs/cpu/softfloat3e/f128_to_f32.c
index 0f6ec2adb..485d68a0c 100644
--- a/bochs/cpu/softfloat3e/f128_to_f32.c
+++ b/bochs/cpu/softfloat3e/f128_to_f32.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f128_to_f32(float128_t a, struct softfloat_status_t *status)
+float32 f128_to_f32(float128_t a, struct softfloat_status_t *status)
 {
     uint64_t uiA64, uiA0;
     bool sign;
diff --git a/bochs/cpu/softfloat3e/f128_to_f64.c b/bochs/cpu/softfloat3e/f128_to_f64.c
index a67a9d09b..0809c7102 100644
--- a/bochs/cpu/softfloat3e/f128_to_f64.c
+++ b/bochs/cpu/softfloat3e/f128_to_f64.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f128_to_f64(float128_t a, struct softfloat_status_t *status)
+float64 f128_to_f64(float128_t a, struct softfloat_status_t *status)
 {
     uint64_t uiA64, uiA0;
     bool sign;
diff --git a/bochs/cpu/softfloat3e/f16_addsub.c b/bochs/cpu/softfloat3e/f16_addsub.c
index 90d45b9e8..0353e054c 100644
--- a/bochs/cpu/softfloat3e/f16_addsub.c
+++ b/bochs/cpu/softfloat3e/f16_addsub.c
@@ -38,10 +38,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-extern float16_t softfloat_addMagsF16(uint16_t, uint16_t, struct softfloat_status_t *);
-extern float16_t softfloat_subMagsF16(uint16_t, uint16_t, struct softfloat_status_t *);
+extern float16 softfloat_addMagsF16(uint16_t, uint16_t, struct softfloat_status_t *);
+extern float16 softfloat_subMagsF16(uint16_t, uint16_t, struct softfloat_status_t *);
 
-float16_t f16_add(float16_t a, float16_t b, struct softfloat_status_t *status)
+float16 f16_add(float16 a, float16 b, struct softfloat_status_t *status)
 {
     if (signF16UI((uint16_t) a ^ (uint16_t) b)) {
         return softfloat_subMagsF16(a, b, status);
@@ -50,7 +50,7 @@ float16_t f16_add(float16_t a, float16_t b, struct softfloat_status_t *status)
     }
 }
 
-float16_t f16_sub(float16_t a, float16_t b, struct softfloat_status_t *status)
+float16 f16_sub(float16 a, float16 b, struct softfloat_status_t *status)
 {
     if (signF16UI((uint16_t) a ^ (uint16_t) b)) {
         return softfloat_addMagsF16(a, b, status);
diff --git a/bochs/cpu/softfloat3e/f16_class.c b/bochs/cpu/softfloat3e/f16_class.c
index 2d3dd6b38..b375c1544 100644
--- a/bochs/cpu/softfloat3e/f16_class.c
+++ b/bochs/cpu/softfloat3e/f16_class.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-softfloat_class_t f16_class(float16_t a)
+softfloat_class_t f16_class(float16 a)
 {
     bool signA;
     int8_t expA;
diff --git a/bochs/cpu/softfloat3e/f16_compare.c b/bochs/cpu/softfloat3e/f16_compare.c
index 42cd257e9..a14eb8104 100644
--- a/bochs/cpu/softfloat3e/f16_compare.c
+++ b/bochs/cpu/softfloat3e/f16_compare.c
@@ -46,7 +46,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | value `b', or 'float_relation_unordered' otherwise.
 *----------------------------------------------------------------------------*/
 
-int f16_compare(float16_t a, float16_t b, bool quiet, struct softfloat_status_t *status)
+int f16_compare(float16 a, float16 b, bool quiet, struct softfloat_status_t *status)
 {
     softfloat_class_t aClass;
     softfloat_class_t bClass;
diff --git a/bochs/cpu/softfloat3e/f16_div.c b/bochs/cpu/softfloat3e/f16_div.c
index 79d30a18e..c91760b03 100644
--- a/bochs/cpu/softfloat3e/f16_div.c
+++ b/bochs/cpu/softfloat3e/f16_div.c
@@ -44,7 +44,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 extern const uint16_t softfloat_approxRecip_1k0s[];
 extern const uint16_t softfloat_approxRecip_1k1s[];
 
-float16_t f16_div(float16_t a, float16_t b, struct softfloat_status_t *status)
+float16 f16_div(float16 a, float16 b, struct softfloat_status_t *status)
 {
     bool signA;
     int8_t expA;
diff --git a/bochs/cpu/softfloat3e/f16_getExp.c b/bochs/cpu/softfloat3e/f16_getExp.c
index a2687c376..6efc28c94 100644
--- a/bochs/cpu/softfloat3e/f16_getExp.c
+++ b/bochs/cpu/softfloat3e/f16_getExp.c
@@ -46,7 +46,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float16_t f16_getExp(float16_t a, struct softfloat_status_t *status)
+float16 f16_getExp(float16 a, struct softfloat_status_t *status)
 {
     int8_t expA;
     uint16_t sigA;
@@ -57,12 +57,12 @@ float16_t f16_getExp(float16_t a, struct softfloat_status_t *status)
 
     if (expA == 0x1F) {
         if (sigA) return softfloat_propagateNaNF16UI(a, 0, status);
-        return packToF32UI(0, 0x1F, 0);
+        return packToF16UI(0, 0x1F, 0);
     }
 
     if (! expA) {
         if (! sigA || softfloat_denormalsAreZeros(status))
-            return packToF32UI(1, 0x1F, 0);
+            return packToF16UI(1, 0x1F, 0);
 
         softfloat_raiseFlags(status, softfloat_flag_denormal);
         normExpSig = softfloat_normSubnormalF16Sig(sigA);
diff --git a/bochs/cpu/softfloat3e/f16_getMant.c b/bochs/cpu/softfloat3e/f16_getMant.c
index 68db0ad44..4c39cac5b 100644
--- a/bochs/cpu/softfloat3e/f16_getMant.c
+++ b/bochs/cpu/softfloat3e/f16_getMant.c
@@ -47,7 +47,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float16_t f16_getMant(float16_t a, softfloat_status_t *status, int sign_ctrl, int interv)
+float16 f16_getMant(float16 a, softfloat_status_t *status, int sign_ctrl, int interv)
 {
     bool signA;
     int8_t expA;
diff --git a/bochs/cpu/softfloat3e/f16_minmax.c b/bochs/cpu/softfloat3e/f16_minmax.c
index cf1e979e3..3aa1454f0 100644
--- a/bochs/cpu/softfloat3e/f16_minmax.c
+++ b/bochs/cpu/softfloat3e/f16_minmax.c
@@ -43,7 +43,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | smaller of them.
 *----------------------------------------------------------------------------*/
 
-float16_t f16_min(float16_t a, float16_t b, struct softfloat_status_t *status)
+float16 f16_min(float16 a, float16 b, struct softfloat_status_t *status)
 {
     if (softfloat_denormalsAreZeros(status)) {
         a = f16_denormal_to_zero(a);
@@ -58,7 +58,7 @@ float16_t f16_min(float16_t a, float16_t b, struct softfloat_status_t *status)
 | larger of them.
 *----------------------------------------------------------------------------*/
 
-float16_t f16_max(float16_t a, float16_t b, struct softfloat_status_t *status)
+float16 f16_max(float16 a, float16 b, struct softfloat_status_t *status)
 {
     if (softfloat_denormalsAreZeros(status)) {
         a = f16_denormal_to_zero(a);
diff --git a/bochs/cpu/softfloat3e/f16_mul.c b/bochs/cpu/softfloat3e/f16_mul.c
index 0850275d8..2e7e74826 100644
--- a/bochs/cpu/softfloat3e/f16_mul.c
+++ b/bochs/cpu/softfloat3e/f16_mul.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f16_mul(float16_t a, float16_t b, struct softfloat_status_t *status)
+float16 f16_mul(float16 a, float16 b, struct softfloat_status_t *status)
 {
     bool signA;
     int8_t expA;
diff --git a/bochs/cpu/softfloat3e/f16_mulAdd.c b/bochs/cpu/softfloat3e/f16_mulAdd.c
index 6e8fafd5b..0e630a9b7 100644
--- a/bochs/cpu/softfloat3e/f16_mulAdd.c
+++ b/bochs/cpu/softfloat3e/f16_mulAdd.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 #include "specialize.h"
 
-float16_t f16_mulAdd(float16_t a, float16_t b, float16_t c, uint8_t op, struct softfloat_status_t *status)
+float16 f16_mulAdd(float16 a, float16 b, float16 c, uint8_t op, struct softfloat_status_t *status)
 {
     bool signA;
     int8_t expA;
diff --git a/bochs/cpu/softfloat3e/f16_range.c b/bochs/cpu/softfloat3e/f16_range.c
index 9909e3ef1..25bb1ccdd 100644
--- a/bochs/cpu/softfloat3e/f16_range.c
+++ b/bochs/cpu/softfloat3e/f16_range.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f16_range(float16_t a, float16_t b, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *status)
+float16 f16_range(float16 a, float16 b, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *status)
 {
     bool signA;
     int8_t expA;
@@ -103,7 +103,7 @@ float16_t f16_range(float16_t a, float16_t b, bool is_max, bool is_abs, int sign
             z = signA ? b : a;
         }
     } else {
-        float16_t tmp_a = a, tmp_b = b;
+        float16 tmp_a = a, tmp_b = b;
         if (is_abs) {
             tmp_a = tmp_a & ~0x8000; // clear the sign bit
             tmp_b = tmp_b & ~0x8000;
diff --git a/bochs/cpu/softfloat3e/f16_roundToInt.c b/bochs/cpu/softfloat3e/f16_roundToInt.c
index e2c9b600c..ee9be0c0b 100644
--- a/bochs/cpu/softfloat3e/f16_roundToInt.c
+++ b/bochs/cpu/softfloat3e/f16_roundToInt.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f16_roundToInt(float16_t a, uint8_t scale, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+float16 f16_roundToInt(float16 a, uint8_t scale, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     int8_t exp;
     uint16_t frac;
diff --git a/bochs/cpu/softfloat3e/f16_sqrt.c b/bochs/cpu/softfloat3e/f16_sqrt.c
index ffc7355f0..f0f8afef1 100644
--- a/bochs/cpu/softfloat3e/f16_sqrt.c
+++ b/bochs/cpu/softfloat3e/f16_sqrt.c
@@ -42,7 +42,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 extern const uint16_t softfloat_approxRecipSqrt_1k0s[];
 extern const uint16_t softfloat_approxRecipSqrt_1k1s[];
 
-float16_t f16_sqrt(float16_t a, struct softfloat_status_t *status)
+float16 f16_sqrt(float16 a, struct softfloat_status_t *status)
 {
     bool signA;
     int8_t expA;
diff --git a/bochs/cpu/softfloat3e/f16_to_extF80.c b/bochs/cpu/softfloat3e/f16_to_extF80.c
index fe027c405..0ce5a1ab1 100644
--- a/bochs/cpu/softfloat3e/f16_to_extF80.c
+++ b/bochs/cpu/softfloat3e/f16_to_extF80.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t f16_to_extF80(float16_t a, struct softfloat_status_t *status)
+extFloat80_t f16_to_extF80(float16 a, struct softfloat_status_t *status)
 {
     bool sign;
     int8_t exp;
diff --git a/bochs/cpu/softfloat3e/f16_to_f32.c b/bochs/cpu/softfloat3e/f16_to_f32.c
index f46afd991..4d862161d 100644
--- a/bochs/cpu/softfloat3e/f16_to_f32.c
+++ b/bochs/cpu/softfloat3e/f16_to_f32.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f16_to_f32(float16_t a, struct softfloat_status_t *status)
+float32 f16_to_f32(float16 a, struct softfloat_status_t *status)
 {
     bool sign;
     int8_t exp;
diff --git a/bochs/cpu/softfloat3e/f16_to_f64.c b/bochs/cpu/softfloat3e/f16_to_f64.c
index 214236510..7d61b6357 100644
--- a/bochs/cpu/softfloat3e/f16_to_f64.c
+++ b/bochs/cpu/softfloat3e/f16_to_f64.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f16_to_f64(float16_t a, struct softfloat_status_t *status)
+float64 f16_to_f64(float16 a, struct softfloat_status_t *status)
 {
     bool sign;
     int8_t exp;
diff --git a/bochs/cpu/softfloat3e/f16_to_i32.c b/bochs/cpu/softfloat3e/f16_to_i32.c
index a7567f1f5..d00cfe236 100644
--- a/bochs/cpu/softfloat3e/f16_to_i32.c
+++ b/bochs/cpu/softfloat3e/f16_to_i32.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int32_t f16_to_i32(float16_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+int32_t f16_to_i32(float16 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int8_t exp;
diff --git a/bochs/cpu/softfloat3e/f16_to_i32_r_minMag.c b/bochs/cpu/softfloat3e/f16_to_i32_r_minMag.c
index 9fcdc15a1..e6673ba3e 100644
--- a/bochs/cpu/softfloat3e/f16_to_i32_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f16_to_i32_r_minMag.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int32_t f16_to_i32_r_minMag(float16_t a, bool exact, struct softfloat_status_t *status)
+int32_t f16_to_i32_r_minMag(float16 a, bool exact, struct softfloat_status_t *status)
 {
     int8_t exp;
     uint16_t frac;
diff --git a/bochs/cpu/softfloat3e/f16_to_i64.c b/bochs/cpu/softfloat3e/f16_to_i64.c
index 32dde7fe0..7dcbeaad8 100644
--- a/bochs/cpu/softfloat3e/f16_to_i64.c
+++ b/bochs/cpu/softfloat3e/f16_to_i64.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int64_t f16_to_i64(float16_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+int64_t f16_to_i64(float16 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int8_t exp;
diff --git a/bochs/cpu/softfloat3e/f16_to_i64_r_minMag.c b/bochs/cpu/softfloat3e/f16_to_i64_r_minMag.c
index 47f0ba375..ec32173de 100644
--- a/bochs/cpu/softfloat3e/f16_to_i64_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f16_to_i64_r_minMag.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int64_t f16_to_i64_r_minMag(float16_t a, bool exact, struct softfloat_status_t *status)
+int64_t f16_to_i64_r_minMag(float16 a, bool exact, struct softfloat_status_t *status)
 {
     int8_t exp;
     uint16_t frac;
diff --git a/bochs/cpu/softfloat3e/f16_to_ui32.c b/bochs/cpu/softfloat3e/f16_to_ui32.c
index bb3769026..d217b2627 100644
--- a/bochs/cpu/softfloat3e/f16_to_ui32.c
+++ b/bochs/cpu/softfloat3e/f16_to_ui32.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint32_t f16_to_ui32(float16_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+uint32_t f16_to_ui32(float16 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int8_t exp;
diff --git a/bochs/cpu/softfloat3e/f16_to_ui32_r_minMag.c b/bochs/cpu/softfloat3e/f16_to_ui32_r_minMag.c
index af3a5ee9a..13eefb24c 100644
--- a/bochs/cpu/softfloat3e/f16_to_ui32_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f16_to_ui32_r_minMag.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint32_t f16_to_ui32_r_minMag(float16_t a, bool exact, struct softfloat_status_t *status)
+uint32_t f16_to_ui32_r_minMag(float16 a, bool exact, struct softfloat_status_t *status)
 {
     int8_t exp;
     uint16_t frac;
diff --git a/bochs/cpu/softfloat3e/f16_to_ui64.c b/bochs/cpu/softfloat3e/f16_to_ui64.c
index 1276ebe4d..351edb32c 100644
--- a/bochs/cpu/softfloat3e/f16_to_ui64.c
+++ b/bochs/cpu/softfloat3e/f16_to_ui64.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint64_t f16_to_ui64(float16_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+uint64_t f16_to_ui64(float16 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int8_t exp;
diff --git a/bochs/cpu/softfloat3e/f16_to_ui64_r_minMag.c b/bochs/cpu/softfloat3e/f16_to_ui64_r_minMag.c
index 35ee06de6..fc4c09ebe 100644
--- a/bochs/cpu/softfloat3e/f16_to_ui64_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f16_to_ui64_r_minMag.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint64_t f16_to_ui64_r_minMag(float16_t a, bool exact, struct softfloat_status_t *status)
+uint64_t f16_to_ui64_r_minMag(float16 a, bool exact, struct softfloat_status_t *status)
 {
     int8_t exp;
     uint16_t frac;
diff --git a/bochs/cpu/softfloat3e/f32_addsub.c b/bochs/cpu/softfloat3e/f32_addsub.c
index 938100e02..0b12d0e76 100644
--- a/bochs/cpu/softfloat3e/f32_addsub.c
+++ b/bochs/cpu/softfloat3e/f32_addsub.c
@@ -38,10 +38,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-extern float32_t softfloat_addMagsF32(uint32_t, uint32_t, struct softfloat_status_t *);
-extern float32_t softfloat_subMagsF32(uint32_t, uint32_t, struct softfloat_status_t *);
+extern float32 softfloat_addMagsF32(uint32_t, uint32_t, struct softfloat_status_t *);
+extern float32 softfloat_subMagsF32(uint32_t, uint32_t, struct softfloat_status_t *);
 
-float32_t f32_add(float32_t a, float32_t b, struct softfloat_status_t *status)
+float32 f32_add(float32 a, float32 b, struct softfloat_status_t *status)
 {
     if (signF32UI((uint32_t) a ^ (uint32_t) b)) {
         return softfloat_subMagsF32(a, b, status);
@@ -50,7 +50,7 @@ float32_t f32_add(float32_t a, float32_t b, struct softfloat_status_t *status)
     }
 }
 
-float32_t f32_sub(float32_t a, float32_t b, struct softfloat_status_t *status)
+float32 f32_sub(float32 a, float32 b, struct softfloat_status_t *status)
 {
     if (signF32UI((uint32_t) a ^ (uint32_t) b)) {
         return softfloat_addMagsF32(a, b, status);
diff --git a/bochs/cpu/softfloat3e/f32_class.c b/bochs/cpu/softfloat3e/f32_class.c
index c01403f82..84c337d0e 100644
--- a/bochs/cpu/softfloat3e/f32_class.c
+++ b/bochs/cpu/softfloat3e/f32_class.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-softfloat_class_t f32_class(float32_t a)
+softfloat_class_t f32_class(float32 a)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f32_compare.c b/bochs/cpu/softfloat3e/f32_compare.c
index 1cf393100..7edb42b88 100644
--- a/bochs/cpu/softfloat3e/f32_compare.c
+++ b/bochs/cpu/softfloat3e/f32_compare.c
@@ -46,7 +46,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | value `b', or 'float_relation_unordered' otherwise.
 *----------------------------------------------------------------------------*/
 
-int f32_compare(float32_t a, float32_t b, bool quiet, struct softfloat_status_t *status)
+int f32_compare(float32 a, float32 b, bool quiet, struct softfloat_status_t *status)
 {
     softfloat_class_t aClass;
     softfloat_class_t bClass;
diff --git a/bochs/cpu/softfloat3e/f32_div.c b/bochs/cpu/softfloat3e/f32_div.c
index 8e959690d..b860af566 100644
--- a/bochs/cpu/softfloat3e/f32_div.c
+++ b/bochs/cpu/softfloat3e/f32_div.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f32_div(float32_t a, float32_t b, struct softfloat_status_t *status)
+float32 f32_div(float32 a, float32 b, struct softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f32_frc.c b/bochs/cpu/softfloat3e/f32_frc.c
index 663649f83..1d3ca0fbf 100644
--- a/bochs/cpu/softfloat3e/f32_frc.c
+++ b/bochs/cpu/softfloat3e/f32_frc.c
@@ -46,7 +46,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float32_t f32_frc(float32_t a, softfloat_status_t *status)
+float32 f32_frc(float32 a, softfloat_status_t *status)
 {
     int roundingMode = softfloat_getRoundingMode(status);
 
diff --git a/bochs/cpu/softfloat3e/f32_getExp.c b/bochs/cpu/softfloat3e/f32_getExp.c
index b45fb0693..66b00ac7c 100644
--- a/bochs/cpu/softfloat3e/f32_getExp.c
+++ b/bochs/cpu/softfloat3e/f32_getExp.c
@@ -46,7 +46,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float32_t f32_getExp(float32_t a, struct softfloat_status_t *status)
+float32 f32_getExp(float32 a, struct softfloat_status_t *status)
 {
     int16_t expA;
     uint32_t sigA;
diff --git a/bochs/cpu/softfloat3e/f32_getMant.c b/bochs/cpu/softfloat3e/f32_getMant.c
index 43d90803d..20fdd3315 100644
--- a/bochs/cpu/softfloat3e/f32_getMant.c
+++ b/bochs/cpu/softfloat3e/f32_getMant.c
@@ -47,7 +47,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float32_t f32_getMant(float32_t a, softfloat_status_t *status, int sign_ctrl, int interv)
+float32 f32_getMant(float32 a, softfloat_status_t *status, int sign_ctrl, int interv)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f32_minmax.c b/bochs/cpu/softfloat3e/f32_minmax.c
index 0bb0449ea..b023f1240 100644
--- a/bochs/cpu/softfloat3e/f32_minmax.c
+++ b/bochs/cpu/softfloat3e/f32_minmax.c
@@ -43,7 +43,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | smaller of them.
 *----------------------------------------------------------------------------*/
 
-float32_t f32_min(float32_t a, float32_t b, struct softfloat_status_t *status)
+float32 f32_min(float32 a, float32 b, struct softfloat_status_t *status)
 {
     if (softfloat_denormalsAreZeros(status)) {
         a = f32_denormal_to_zero(a);
@@ -58,7 +58,7 @@ float32_t f32_min(float32_t a, float32_t b, struct softfloat_status_t *status)
 | larger of them.
 *----------------------------------------------------------------------------*/
 
-float32_t f32_max(float32_t a, float32_t b, struct softfloat_status_t *status)
+float32 f32_max(float32 a, float32 b, struct softfloat_status_t *status)
 {
     if (softfloat_denormalsAreZeros(status)) {
         a = f32_denormal_to_zero(a);
diff --git a/bochs/cpu/softfloat3e/f32_mul.c b/bochs/cpu/softfloat3e/f32_mul.c
index 2ebec0f2a..db96e0db7 100644
--- a/bochs/cpu/softfloat3e/f32_mul.c
+++ b/bochs/cpu/softfloat3e/f32_mul.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f32_mul(float32_t a, float32_t b, struct softfloat_status_t *status)
+float32 f32_mul(float32 a, float32 b, struct softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f32_mulAdd.c b/bochs/cpu/softfloat3e/f32_mulAdd.c
index 42edd69d6..101b20f18 100644
--- a/bochs/cpu/softfloat3e/f32_mulAdd.c
+++ b/bochs/cpu/softfloat3e/f32_mulAdd.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 #include "specialize.h"
 
-float32_t f32_mulAdd(float32_t a, float32_t b, float32_t c, uint8_t op, struct softfloat_status_t *status)
+float32 f32_mulAdd(float32 a, float32 b, float32 c, uint8_t op, struct softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f32_range.c b/bochs/cpu/softfloat3e/f32_range.c
index bc3153d52..bb1af93ff 100644
--- a/bochs/cpu/softfloat3e/f32_range.c
+++ b/bochs/cpu/softfloat3e/f32_range.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f32_range(float32_t a, float32_t b, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *status)
+float32 f32_range(float32 a, float32 b, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
@@ -103,7 +103,7 @@ float32_t f32_range(float32_t a, float32_t b, bool is_max, bool is_abs, int sign
             z = signA ? b : a;
         }
     } else {
-        float32_t tmp_a = a, tmp_b = b;
+        float32 tmp_a = a, tmp_b = b;
         if (is_abs) {
             tmp_a = tmp_a & ~0x80000000; // clear the sign bit
             tmp_b = tmp_b & ~0x80000000;
diff --git a/bochs/cpu/softfloat3e/f32_roundToInt.c b/bochs/cpu/softfloat3e/f32_roundToInt.c
index 189b9a2bb..7791fbbf4 100644
--- a/bochs/cpu/softfloat3e/f32_roundToInt.c
+++ b/bochs/cpu/softfloat3e/f32_roundToInt.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f32_roundToInt(float32_t a, uint8_t scale, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+float32 f32_roundToInt(float32 a, uint8_t scale, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     int16_t exp;
     int32_t frac;
diff --git a/bochs/cpu/softfloat3e/f32_scalef.c b/bochs/cpu/softfloat3e/f32_scalef.c
index f39292347..320baff30 100644
--- a/bochs/cpu/softfloat3e/f32_scalef.c
+++ b/bochs/cpu/softfloat3e/f32_scalef.c
@@ -49,7 +49,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float32_t f32_scalef(float32_t a, float32_t b, struct softfloat_status_t *status)
+float32 f32_scalef(float32 a, float32 b, struct softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f32_sqrt.c b/bochs/cpu/softfloat3e/f32_sqrt.c
index 9ef9cb493..fc2ef8f76 100644
--- a/bochs/cpu/softfloat3e/f32_sqrt.c
+++ b/bochs/cpu/softfloat3e/f32_sqrt.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f32_sqrt(float32_t a, struct softfloat_status_t *status)
+float32 f32_sqrt(float32 a, struct softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f32_to_extF80.c b/bochs/cpu/softfloat3e/f32_to_extF80.c
index 6b7ce1b50..095f85165 100644
--- a/bochs/cpu/softfloat3e/f32_to_extF80.c
+++ b/bochs/cpu/softfloat3e/f32_to_extF80.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t f32_to_extF80(float32_t a, struct softfloat_status_t *status)
+extFloat80_t f32_to_extF80(float32 a, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f32_to_f128.c b/bochs/cpu/softfloat3e/f32_to_f128.c
index 9b105f39c..6d3fafec2 100644
--- a/bochs/cpu/softfloat3e/f32_to_f128.c
+++ b/bochs/cpu/softfloat3e/f32_to_f128.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float128_t f32_to_f128(float32_t a, struct softfloat_status_t *status)
+float128_t f32_to_f128(float32 a, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f32_to_f16.c b/bochs/cpu/softfloat3e/f32_to_f16.c
index 59402398d..9253a958a 100644
--- a/bochs/cpu/softfloat3e/f32_to_f16.c
+++ b/bochs/cpu/softfloat3e/f32_to_f16.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f32_to_f16(float32_t a, struct softfloat_status_t *status)
+float16 f32_to_f16(float32 a, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f32_to_f64.c b/bochs/cpu/softfloat3e/f32_to_f64.c
index be1e53255..28ebb61b6 100644
--- a/bochs/cpu/softfloat3e/f32_to_f64.c
+++ b/bochs/cpu/softfloat3e/f32_to_f64.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f32_to_f64(float32_t a, struct softfloat_status_t *status)
+float64 f32_to_f64(float32 a, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f32_to_i32.c b/bochs/cpu/softfloat3e/f32_to_i32.c
index 29d2aad33..2b3df52a3 100644
--- a/bochs/cpu/softfloat3e/f32_to_i32.c
+++ b/bochs/cpu/softfloat3e/f32_to_i32.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int32_t f32_to_i32(float32_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+int32_t f32_to_i32(float32 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f32_to_i32_r_minMag.c b/bochs/cpu/softfloat3e/f32_to_i32_r_minMag.c
index 0c2d68365..d83c7bcaa 100644
--- a/bochs/cpu/softfloat3e/f32_to_i32_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f32_to_i32_r_minMag.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int32_t f32_to_i32_r_minMag(float32_t a, bool exact, struct softfloat_status_t *status)
+int32_t f32_to_i32_r_minMag(float32 a, bool exact, struct softfloat_status_t *status)
 {
     int16_t exp;
     uint32_t sig;
diff --git a/bochs/cpu/softfloat3e/f32_to_i64.c b/bochs/cpu/softfloat3e/f32_to_i64.c
index d10de2565..8f715c4e2 100644
--- a/bochs/cpu/softfloat3e/f32_to_i64.c
+++ b/bochs/cpu/softfloat3e/f32_to_i64.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int64_t f32_to_i64(float32_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+int64_t f32_to_i64(float32 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f32_to_i64_r_minMag.c b/bochs/cpu/softfloat3e/f32_to_i64_r_minMag.c
index f600f23cf..ab813b9df 100644
--- a/bochs/cpu/softfloat3e/f32_to_i64_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f32_to_i64_r_minMag.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int64_t f32_to_i64_r_minMag(float32_t a, bool exact, struct softfloat_status_t *status)
+int64_t f32_to_i64_r_minMag(float32 a, bool exact, struct softfloat_status_t *status)
 {
     int16_t exp;
     uint32_t sig;
diff --git a/bochs/cpu/softfloat3e/f32_to_ui32.c b/bochs/cpu/softfloat3e/f32_to_ui32.c
index d85c794fb..5a8d57414 100644
--- a/bochs/cpu/softfloat3e/f32_to_ui32.c
+++ b/bochs/cpu/softfloat3e/f32_to_ui32.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint32_t f32_to_ui32(float32_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+uint32_t f32_to_ui32(float32 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f32_to_ui32_r_minMag.c b/bochs/cpu/softfloat3e/f32_to_ui32_r_minMag.c
index 1d5ec62ca..26bdae31f 100644
--- a/bochs/cpu/softfloat3e/f32_to_ui32_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f32_to_ui32_r_minMag.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint32_t f32_to_ui32_r_minMag(float32_t a, bool exact, struct softfloat_status_t *status)
+uint32_t f32_to_ui32_r_minMag(float32 a, bool exact, struct softfloat_status_t *status)
 {
     int16_t exp;
     uint32_t sig;
diff --git a/bochs/cpu/softfloat3e/f32_to_ui64.c b/bochs/cpu/softfloat3e/f32_to_ui64.c
index 4367e5385..c5de58b23 100644
--- a/bochs/cpu/softfloat3e/f32_to_ui64.c
+++ b/bochs/cpu/softfloat3e/f32_to_ui64.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint64_t f32_to_ui64(float32_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+uint64_t f32_to_ui64(float32 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f32_to_ui64_r_minMag.c b/bochs/cpu/softfloat3e/f32_to_ui64_r_minMag.c
index ec0f50512..71227e487 100644
--- a/bochs/cpu/softfloat3e/f32_to_ui64_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f32_to_ui64_r_minMag.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint64_t f32_to_ui64_r_minMag(float32_t a, bool exact, struct softfloat_status_t *status)
+uint64_t f32_to_ui64_r_minMag(float32 a, bool exact, struct softfloat_status_t *status)
 {
     int16_t exp;
     uint32_t sig;
diff --git a/bochs/cpu/softfloat3e/f64_addsub.c b/bochs/cpu/softfloat3e/f64_addsub.c
index 865059dcb..6c5acb4f7 100644
--- a/bochs/cpu/softfloat3e/f64_addsub.c
+++ b/bochs/cpu/softfloat3e/f64_addsub.c
@@ -38,10 +38,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-extern float64_t softfloat_addMagsF64(uint64_t, uint64_t, bool, struct softfloat_status_t *);
-extern float64_t softfloat_subMagsF64(uint64_t, uint64_t, bool, struct softfloat_status_t *);
+extern float64 softfloat_addMagsF64(uint64_t, uint64_t, bool, struct softfloat_status_t *);
+extern float64 softfloat_subMagsF64(uint64_t, uint64_t, bool, struct softfloat_status_t *);
 
-float64_t f64_add(float64_t a, float64_t b, struct softfloat_status_t *status)
+float64 f64_add(float64 a, float64 b, struct softfloat_status_t *status)
 {
     bool signA;
     bool signB;
@@ -55,7 +55,7 @@ float64_t f64_add(float64_t a, float64_t b, struct softfloat_status_t *status)
     }
 }
 
-float64_t f64_sub(float64_t a, float64_t b, struct softfloat_status_t *status)
+float64 f64_sub(float64 a, float64 b, struct softfloat_status_t *status)
 {
     bool signA;
     bool signB;
diff --git a/bochs/cpu/softfloat3e/f64_class.c b/bochs/cpu/softfloat3e/f64_class.c
index 43970e57d..1d44a6351 100644
--- a/bochs/cpu/softfloat3e/f64_class.c
+++ b/bochs/cpu/softfloat3e/f64_class.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-softfloat_class_t f64_class(float64_t a)
+softfloat_class_t f64_class(float64 a)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f64_compare.c b/bochs/cpu/softfloat3e/f64_compare.c
index 8ee6710ec..aca292fda 100644
--- a/bochs/cpu/softfloat3e/f64_compare.c
+++ b/bochs/cpu/softfloat3e/f64_compare.c
@@ -46,7 +46,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | value `b', or 'float_relation_unordered' otherwise.
 *----------------------------------------------------------------------------*/
 
-int f64_compare(float64_t a, float64_t b, bool quiet, struct softfloat_status_t *status)
+int f64_compare(float64 a, float64 b, bool quiet, struct softfloat_status_t *status)
 {
     softfloat_class_t aClass;
     softfloat_class_t bClass;
diff --git a/bochs/cpu/softfloat3e/f64_div.c b/bochs/cpu/softfloat3e/f64_div.c
index ae3f384cf..89f74f1b1 100644
--- a/bochs/cpu/softfloat3e/f64_div.c
+++ b/bochs/cpu/softfloat3e/f64_div.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f64_div(float64_t a, float64_t b, struct softfloat_status_t *status)
+float64 f64_div(float64 a, float64 b, struct softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f64_frc.c b/bochs/cpu/softfloat3e/f64_frc.c
index 1a741d233..e39847665 100644
--- a/bochs/cpu/softfloat3e/f64_frc.c
+++ b/bochs/cpu/softfloat3e/f64_frc.c
@@ -46,7 +46,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float64_t f64_frc(float64_t a, softfloat_status_t *status)
+float64 f64_frc(float64 a, softfloat_status_t *status)
 {
     int roundingMode = softfloat_getRoundingMode(status);
 
diff --git a/bochs/cpu/softfloat3e/f64_getExp.c b/bochs/cpu/softfloat3e/f64_getExp.c
index 6fd98e981..b76cc996d 100644
--- a/bochs/cpu/softfloat3e/f64_getExp.c
+++ b/bochs/cpu/softfloat3e/f64_getExp.c
@@ -46,7 +46,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float64_t f64_getExp(float64_t a, struct softfloat_status_t *status)
+float64 f64_getExp(float64 a, struct softfloat_status_t *status)
 {
     int16_t expA;
     uint64_t sigA;
diff --git a/bochs/cpu/softfloat3e/f64_getMant.c b/bochs/cpu/softfloat3e/f64_getMant.c
index 4571f4526..459200cac 100644
--- a/bochs/cpu/softfloat3e/f64_getMant.c
+++ b/bochs/cpu/softfloat3e/f64_getMant.c
@@ -47,7 +47,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float64_t f64_getMant(float64_t a, softfloat_status_t *status, int sign_ctrl, int interv)
+float64 f64_getMant(float64 a, softfloat_status_t *status, int sign_ctrl, int interv)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f64_minmax.c b/bochs/cpu/softfloat3e/f64_minmax.c
index d81d136b1..e74841dfa 100644
--- a/bochs/cpu/softfloat3e/f64_minmax.c
+++ b/bochs/cpu/softfloat3e/f64_minmax.c
@@ -43,7 +43,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | smaller of them.
 *----------------------------------------------------------------------------*/
 
-float64_t f64_min(float64_t a, float64_t b, struct softfloat_status_t *status)
+float64 f64_min(float64 a, float64 b, struct softfloat_status_t *status)
 {
     if (softfloat_denormalsAreZeros(status)) {
         a = f64_denormal_to_zero(a);
@@ -58,7 +58,7 @@ float64_t f64_min(float64_t a, float64_t b, struct softfloat_status_t *status)
 | larger of them.
 *----------------------------------------------------------------------------*/
 
-float64_t f64_max(float64_t a, float64_t b, struct softfloat_status_t *status)
+float64 f64_max(float64 a, float64 b, struct softfloat_status_t *status)
 {
     if (softfloat_denormalsAreZeros(status)) {
         a = f64_denormal_to_zero(a);
diff --git a/bochs/cpu/softfloat3e/f64_mul.c b/bochs/cpu/softfloat3e/f64_mul.c
index 5ce1c4689..c1e98f2b6 100644
--- a/bochs/cpu/softfloat3e/f64_mul.c
+++ b/bochs/cpu/softfloat3e/f64_mul.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f64_mul(float64_t a, float64_t b, struct softfloat_status_t *status)
+float64 f64_mul(float64 a, float64 b, struct softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f64_mulAdd.c b/bochs/cpu/softfloat3e/f64_mulAdd.c
index c98edea6c..9623b4980 100644
--- a/bochs/cpu/softfloat3e/f64_mulAdd.c
+++ b/bochs/cpu/softfloat3e/f64_mulAdd.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "softfloat.h"
 #include "specialize.h"
 
-float64_t f64_mulAdd(float64_t a, float64_t b, float64_t c, uint8_t op, struct softfloat_status_t *status)
+float64 f64_mulAdd(float64 a, float64 b, float64 c, uint8_t op, struct softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f64_range.c b/bochs/cpu/softfloat3e/f64_range.c
index fe4aa3e02..1025f474d 100644
--- a/bochs/cpu/softfloat3e/f64_range.c
+++ b/bochs/cpu/softfloat3e/f64_range.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f64_range(float64_t a, float64_t b, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *status)
+float64 f64_range(float64 a, float64 b, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
@@ -103,7 +103,7 @@ float64_t f64_range(float64_t a, float64_t b, bool is_max, bool is_abs, int sign
             z = signA ? b : a;
         }
     } else {
-        float64_t tmp_a = a, tmp_b = b;
+        float64 tmp_a = a, tmp_b = b;
         if (is_abs) {
             tmp_a = tmp_a & ~UINT64_C(0x8000000000000000); // clear the sign bit
             tmp_b = tmp_b & ~UINT64_C(0x8000000000000000);
diff --git a/bochs/cpu/softfloat3e/f64_roundToInt.c b/bochs/cpu/softfloat3e/f64_roundToInt.c
index 591f1574f..3c5f7fb8c 100644
--- a/bochs/cpu/softfloat3e/f64_roundToInt.c
+++ b/bochs/cpu/softfloat3e/f64_roundToInt.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f64_roundToInt(float64_t a, uint8_t scale, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+float64 f64_roundToInt(float64 a, uint8_t scale, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     int16_t exp;
     int64_t frac;
diff --git a/bochs/cpu/softfloat3e/f64_scalef.c b/bochs/cpu/softfloat3e/f64_scalef.c
index 068466738..7a552ccc3 100644
--- a/bochs/cpu/softfloat3e/f64_scalef.c
+++ b/bochs/cpu/softfloat3e/f64_scalef.c
@@ -49,7 +49,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float64_t f64_scalef(float64_t a, float64_t b, struct softfloat_status_t *status)
+float64 f64_scalef(float64 a, float64 b, struct softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f64_sqrt.c b/bochs/cpu/softfloat3e/f64_sqrt.c
index 7542c97b3..d3ea81af8 100644
--- a/bochs/cpu/softfloat3e/f64_sqrt.c
+++ b/bochs/cpu/softfloat3e/f64_sqrt.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t f64_sqrt(float64_t a, struct softfloat_status_t *status)
+float64 f64_sqrt(float64 a, struct softfloat_status_t *status)
 {
     bool signA;
     int16_t expA;
diff --git a/bochs/cpu/softfloat3e/f64_to_extF80.c b/bochs/cpu/softfloat3e/f64_to_extF80.c
index 6fab74d0b..9284d69bb 100644
--- a/bochs/cpu/softfloat3e/f64_to_extF80.c
+++ b/bochs/cpu/softfloat3e/f64_to_extF80.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-extFloat80_t f64_to_extF80(float64_t a, struct softfloat_status_t *status)
+extFloat80_t f64_to_extF80(float64 a, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f64_to_f128.c b/bochs/cpu/softfloat3e/f64_to_f128.c
index 0a862c092..cfae72824 100644
--- a/bochs/cpu/softfloat3e/f64_to_f128.c
+++ b/bochs/cpu/softfloat3e/f64_to_f128.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float128_t f64_to_f128(float64_t a, struct softfloat_status_t *status)
+float128_t f64_to_f128(float64 a, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f64_to_f16.c b/bochs/cpu/softfloat3e/f64_to_f16.c
index 9e7403638..fe8dea057 100644
--- a/bochs/cpu/softfloat3e/f64_to_f16.c
+++ b/bochs/cpu/softfloat3e/f64_to_f16.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t f64_to_f16(float64_t a, struct softfloat_status_t *status)
+float16 f64_to_f16(float64 a, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f64_to_f32.c b/bochs/cpu/softfloat3e/f64_to_f32.c
index e183c8961..7ebbf428f 100644
--- a/bochs/cpu/softfloat3e/f64_to_f32.c
+++ b/bochs/cpu/softfloat3e/f64_to_f32.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t f64_to_f32(float64_t a, struct softfloat_status_t *status)
+float32 f64_to_f32(float64 a, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f64_to_i32.c b/bochs/cpu/softfloat3e/f64_to_i32.c
index 26ed9f7c9..c296e0bd5 100644
--- a/bochs/cpu/softfloat3e/f64_to_i32.c
+++ b/bochs/cpu/softfloat3e/f64_to_i32.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int32_t f64_to_i32(float64_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+int32_t f64_to_i32(float64 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f64_to_i32_r_minMag.c b/bochs/cpu/softfloat3e/f64_to_i32_r_minMag.c
index 25cfd2850..c58d17ab2 100644
--- a/bochs/cpu/softfloat3e/f64_to_i32_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f64_to_i32_r_minMag.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int32_t f64_to_i32_r_minMag(float64_t a, bool exact, struct softfloat_status_t *status)
+int32_t f64_to_i32_r_minMag(float64 a, bool exact, struct softfloat_status_t *status)
 {
     int16_t exp;
     uint64_t sig;
diff --git a/bochs/cpu/softfloat3e/f64_to_i64.c b/bochs/cpu/softfloat3e/f64_to_i64.c
index 0bce25760..96381033b 100644
--- a/bochs/cpu/softfloat3e/f64_to_i64.c
+++ b/bochs/cpu/softfloat3e/f64_to_i64.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int64_t f64_to_i64(float64_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+int64_t f64_to_i64(float64 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f64_to_i64_r_minMag.c b/bochs/cpu/softfloat3e/f64_to_i64_r_minMag.c
index fec7ffbc6..72617b84d 100644
--- a/bochs/cpu/softfloat3e/f64_to_i64_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f64_to_i64_r_minMag.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-int64_t f64_to_i64_r_minMag(float64_t a, bool exact, struct softfloat_status_t *status)
+int64_t f64_to_i64_r_minMag(float64 a, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f64_to_ui32.c b/bochs/cpu/softfloat3e/f64_to_ui32.c
index 8495bb118..1dad1bc32 100644
--- a/bochs/cpu/softfloat3e/f64_to_ui32.c
+++ b/bochs/cpu/softfloat3e/f64_to_ui32.c
@@ -41,7 +41,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint32_t f64_to_ui32(float64_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+uint32_t f64_to_ui32(float64 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f64_to_ui32_r_minMag.c b/bochs/cpu/softfloat3e/f64_to_ui32_r_minMag.c
index 568487345..f89fce4ba 100644
--- a/bochs/cpu/softfloat3e/f64_to_ui32_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f64_to_ui32_r_minMag.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint32_t f64_to_ui32_r_minMag(float64_t a, bool exact, struct softfloat_status_t *status)
+uint32_t f64_to_ui32_r_minMag(float64 a, bool exact, struct softfloat_status_t *status)
 {
     int16_t exp;
     uint64_t sig;
diff --git a/bochs/cpu/softfloat3e/f64_to_ui64.c b/bochs/cpu/softfloat3e/f64_to_ui64.c
index 12f8f057a..98e6402e2 100644
--- a/bochs/cpu/softfloat3e/f64_to_ui64.c
+++ b/bochs/cpu/softfloat3e/f64_to_ui64.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint64_t f64_to_ui64(float64_t a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
+uint64_t f64_to_ui64(float64 a, uint8_t roundingMode, bool exact, struct softfloat_status_t *status)
 {
     bool sign;
     int16_t exp;
diff --git a/bochs/cpu/softfloat3e/f64_to_ui64_r_minMag.c b/bochs/cpu/softfloat3e/f64_to_ui64_r_minMag.c
index b55537b7a..e7bda4c67 100644
--- a/bochs/cpu/softfloat3e/f64_to_ui64_r_minMag.c
+++ b/bochs/cpu/softfloat3e/f64_to_ui64_r_minMag.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-uint64_t f64_to_ui64_r_minMag(float64_t a, bool exact, struct softfloat_status_t *status)
+uint64_t f64_to_ui64_r_minMag(float64 a, bool exact, struct softfloat_status_t *status)
 {
     int16_t exp;
     uint64_t sig;
diff --git a/bochs/cpu/softfloat3e/i32_to_f16.c b/bochs/cpu/softfloat3e/i32_to_f16.c
index eb9ec831d..3d017a7b7 100644
--- a/bochs/cpu/softfloat3e/i32_to_f16.c
+++ b/bochs/cpu/softfloat3e/i32_to_f16.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float16_t i32_to_f16(int32_t a, struct softfloat_status_t *status)
+float16 i32_to_f16(int32_t a, struct softfloat_status_t *status)
 {
     bool sign;
     uint32_t absA;
diff --git a/bochs/cpu/softfloat3e/i32_to_f32.c b/bochs/cpu/softfloat3e/i32_to_f32.c
index 14325326a..f2742d24d 100644
--- a/bochs/cpu/softfloat3e/i32_to_f32.c
+++ b/bochs/cpu/softfloat3e/i32_to_f32.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float32_t i32_to_f32(int32_t a, struct softfloat_status_t *status)
+float32 i32_to_f32(int32_t a, struct softfloat_status_t *status)
 {
     bool sign;
     uint32_t absA;
diff --git a/bochs/cpu/softfloat3e/i32_to_f64.c b/bochs/cpu/softfloat3e/i32_to_f64.c
index 4c34b231b..7aaa4e1c2 100644
--- a/bochs/cpu/softfloat3e/i32_to_f64.c
+++ b/bochs/cpu/softfloat3e/i32_to_f64.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float64_t i32_to_f64(int32_t a)
+float64 i32_to_f64(int32_t a)
 {
     bool sign;
     uint32_t absA;
diff --git a/bochs/cpu/softfloat3e/i64_to_f16.c b/bochs/cpu/softfloat3e/i64_to_f16.c
index c9da24878..43873610a 100644
--- a/bochs/cpu/softfloat3e/i64_to_f16.c
+++ b/bochs/cpu/softfloat3e/i64_to_f16.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float16_t i64_to_f16(int64_t a, struct softfloat_status_t *status)
+float16 i64_to_f16(int64_t a, struct softfloat_status_t *status)
 {
     bool sign;
     uint64_t absA;
diff --git a/bochs/cpu/softfloat3e/i64_to_f32.c b/bochs/cpu/softfloat3e/i64_to_f32.c
index 6d4fa0079..ae929be2d 100644
--- a/bochs/cpu/softfloat3e/i64_to_f32.c
+++ b/bochs/cpu/softfloat3e/i64_to_f32.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float32_t i64_to_f32(int64_t a, struct softfloat_status_t *status)
+float32 i64_to_f32(int64_t a, struct softfloat_status_t *status)
 {
     bool sign;
     uint64_t absA;
diff --git a/bochs/cpu/softfloat3e/i64_to_f64.c b/bochs/cpu/softfloat3e/i64_to_f64.c
index f20333250..b217354af 100644
--- a/bochs/cpu/softfloat3e/i64_to_f64.c
+++ b/bochs/cpu/softfloat3e/i64_to_f64.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float64_t i64_to_f64(int64_t a, struct softfloat_status_t *status)
+float64 i64_to_f64(int64_t a, struct softfloat_status_t *status)
 {
     bool sign;
     uint64_t absA;
diff --git a/bochs/cpu/softfloat3e/include/internals.h b/bochs/cpu/softfloat3e/include/internals.h
index 4ee6409f6..2a2ed8bc4 100644
--- a/bochs/cpu/softfloat3e/include/internals.h
+++ b/bochs/cpu/softfloat3e/include/internals.h
@@ -63,23 +63,23 @@ int64_t softfloat_roundToI64(bool, uint64_t, uint64_t, uint8_t, bool, struct sof
 struct exp8_sig16 { int8_t exp; uint16_t sig; };
 struct exp8_sig16 softfloat_normSubnormalF16Sig(uint16_t);
 
-float16_t softfloat_roundPackToF16(bool, int16_t, uint16_t, struct softfloat_status_t *);
-float16_t softfloat_normRoundPackToF16(bool, int16_t, uint16_t, struct softfloat_status_t *);
+float16 softfloat_roundPackToF16(bool, int16_t, uint16_t, struct softfloat_status_t *);
+float16 softfloat_normRoundPackToF16(bool, int16_t, uint16_t, struct softfloat_status_t *);
 
 /*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
 #define signF32UI(a) ((bool) ((uint32_t) (a)>>31))
 #define expF32UI(a) ((int16_t) ((a)>>23) & 0xFF)
 #define fracF32UI(a) ((a) & 0x007FFFFF)
-#define packToF32UI(sign, exp, sig) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<23) + (sig))
+#define packToF32UI(sign, exp, sig) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<23) + (uint32_t)(sig))
 
 #define isNaNF32UI(a) (((~(a) & 0x7F800000) == 0) && ((a) & 0x007FFFFF))
 
 struct exp16_sig32 { int16_t exp; uint32_t sig; };
 struct exp16_sig32 softfloat_normSubnormalF32Sig(uint32_t);
 
-float32_t softfloat_roundPackToF32(bool, int16_t, uint32_t, struct softfloat_status_t *);
-float32_t softfloat_normRoundPackToF32(bool, int16_t, uint32_t, struct softfloat_status_t *);
+float32 softfloat_roundPackToF32(bool, int16_t, uint32_t, struct softfloat_status_t *);
+float32 softfloat_normRoundPackToF32(bool, int16_t, uint32_t, struct softfloat_status_t *);
 
 /*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
@@ -93,8 +93,8 @@ float32_t softfloat_normRoundPackToF32(bool, int16_t, uint32_t, struct softfloat
 struct exp16_sig64 { int16_t exp; uint64_t sig; };
 struct exp16_sig64 softfloat_normSubnormalF64Sig(uint64_t);
 
-float64_t softfloat_roundPackToF64(bool, int16_t, uint64_t, struct softfloat_status_t *);
-float64_t softfloat_normRoundPackToF64(bool, int16_t, uint64_t, struct softfloat_status_t *);
+float64 softfloat_roundPackToF64(bool, int16_t, uint64_t, struct softfloat_status_t *);
+float64 softfloat_normRoundPackToF64(bool, int16_t, uint64_t, struct softfloat_status_t *);
 
 /*----------------------------------------------------------------------------
 *----------------------------------------------------------------------------*/
diff --git a/bochs/cpu/softfloat3e/include/softfloat-compare.h b/bochs/cpu/softfloat3e/include/softfloat-compare.h
index 9d256e198..b7f13af31 100644
--- a/bochs/cpu/softfloat3e/include/softfloat-compare.h
+++ b/bochs/cpu/softfloat3e/include/softfloat-compare.h
@@ -40,227 +40,227 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ======= float16 ======= //
 
-typedef int (*float16_compare_method)(float16_t, float16_t, softfloat_status_t *status);
+typedef int (*float16_compare_method)(float16, float16, softfloat_status_t *status);
 
 // 0x00
-BX_CPP_INLINE int f16_eq_ordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_eq_ordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation == softfloat_relation_equal);
 }
 
 // 0x01
-BX_CPP_INLINE int f16_lt_ordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_lt_ordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation == softfloat_relation_less);
 }
 
 // 0x02
-BX_CPP_INLINE int f16_le_ordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_le_ordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_equal);
 }
 
 // 0x03
-BX_CPP_INLINE int f16_unordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_unordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation == softfloat_relation_unordered);
 }
 
 // 0x04
-BX_CPP_INLINE int f16_neq_unordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_neq_unordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation != softfloat_relation_equal);
 }
 
 // 0x05
-BX_CPP_INLINE int f16_nlt_unordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_nlt_unordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation != softfloat_relation_less);
 }
 
 // 0x06
-BX_CPP_INLINE int f16_nle_unordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_nle_unordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation != softfloat_relation_less) && (relation != softfloat_relation_equal);
 }
 
 // 0x07
-BX_CPP_INLINE int f16_ordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_ordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation != softfloat_relation_unordered);
 }
 
 // 0x08
-BX_CPP_INLINE int f16_eq_unordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_eq_unordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation == softfloat_relation_equal) || (relation == softfloat_relation_unordered);
 }
 
 // 0x09
-BX_CPP_INLINE int f16_nge_unordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_nge_unordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_unordered);
 }
 
 // 0x0a
-BX_CPP_INLINE int f16_ngt_unordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_ngt_unordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation != softfloat_relation_greater);
 }
 
 // 0x0b
-BX_CPP_INLINE int f16_false_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_false_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    f16_compare_quiet(a, b, status);
    return 0;
 }
 
 // 0x0c
-BX_CPP_INLINE int f16_neq_ordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_neq_ordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation != softfloat_relation_equal) && (relation != softfloat_relation_unordered);
 }
 
 // 0x0d
-BX_CPP_INLINE int f16_ge_ordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_ge_ordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation == softfloat_relation_greater) || (relation == softfloat_relation_equal);
 }
 
 // 0x0e
-BX_CPP_INLINE int f16_gt_ordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_gt_ordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation == softfloat_relation_greater);
 }
 
 // 0x0f
-BX_CPP_INLINE int f16_true_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_true_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    f16_compare_quiet(a, b, status);
    return 1;
 }
 
 // 0x10
-BX_CPP_INLINE int f16_eq_ordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_eq_ordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation == softfloat_relation_equal);
 }
 
 // 0x11
-BX_CPP_INLINE int f16_lt_ordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_lt_ordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation == softfloat_relation_less);
 }
 
 // 0x12
-BX_CPP_INLINE int f16_le_ordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_le_ordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_equal);
 }
 
 // 0x13
-BX_CPP_INLINE int f16_unordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_unordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation == softfloat_relation_unordered);
 }
 
 // 0x14
-BX_CPP_INLINE int f16_neq_unordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_neq_unordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation != softfloat_relation_equal);
 }
 
 // 0x15
-BX_CPP_INLINE int f16_nlt_unordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_nlt_unordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation != softfloat_relation_less);
 }
 
 // 0x16
-BX_CPP_INLINE int f16_nle_unordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_nle_unordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation != softfloat_relation_less) && (relation != softfloat_relation_equal);
 }
 
 // 0x17
-BX_CPP_INLINE int f16_ordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_ordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation != softfloat_relation_unordered);
 }
 
 // 0x18
-BX_CPP_INLINE int f16_eq_unordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_eq_unordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation == softfloat_relation_equal) || (relation == softfloat_relation_unordered);
 }
 
 // 0x19
-BX_CPP_INLINE int f16_nge_unordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_nge_unordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_unordered);
 }
 
 // 0x1a
-BX_CPP_INLINE int f16_ngt_unordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_ngt_unordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation != softfloat_relation_greater);
 }
 
 // 0x1b
-BX_CPP_INLINE int f16_false_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_false_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    f16_compare(a, b, status);
    return 0;
 }
 
 // 0x1c
-BX_CPP_INLINE int f16_neq_ordered_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_neq_ordered_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare(a, b, status);
    return (relation != softfloat_relation_equal) && (relation != softfloat_relation_unordered);
 }
 
 // 0x1d
-BX_CPP_INLINE int f16_ge_ordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_ge_ordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation == softfloat_relation_greater) || (relation == softfloat_relation_equal);
 }
 
 // 0x1e
-BX_CPP_INLINE int f16_gt_ordered_quiet(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_gt_ordered_quiet(float16 a, float16 b, softfloat_status_t *status)
 {
    int relation = f16_compare_quiet(a, b, status);
    return (relation == softfloat_relation_greater);
 }
 
 // 0x1f
-BX_CPP_INLINE int f16_true_signalling(float16_t a, float16_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f16_true_signalling(float16 a, float16 b, softfloat_status_t *status)
 {
    f16_compare(a, b, status);
    return 1;
@@ -268,227 +268,227 @@ BX_CPP_INLINE int f16_true_signalling(float16_t a, float16_t b, softfloat_status
 
 // ======= float32 ======= //
 
-typedef int (*float32_compare_method)(float32_t, float32_t, softfloat_status_t *status);
+typedef int (*float32_compare_method)(float32, float32, softfloat_status_t *status);
 
 // 0x00
-BX_CPP_INLINE int f32_eq_ordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_eq_ordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation == softfloat_relation_equal);
 }
 
 // 0x01
-BX_CPP_INLINE int f32_lt_ordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_lt_ordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation == softfloat_relation_less);
 }
 
 // 0x02
-BX_CPP_INLINE int f32_le_ordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_le_ordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_equal);
 }
 
 // 0x03
-BX_CPP_INLINE int f32_unordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_unordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation == softfloat_relation_unordered);
 }
 
 // 0x04
-BX_CPP_INLINE int f32_neq_unordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_neq_unordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation != softfloat_relation_equal);
 }
 
 // 0x05
-BX_CPP_INLINE int f32_nlt_unordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_nlt_unordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation != softfloat_relation_less);
 }
 
 // 0x06
-BX_CPP_INLINE int f32_nle_unordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_nle_unordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation != softfloat_relation_less) && (relation != softfloat_relation_equal);
 }
 
 // 0x07
-BX_CPP_INLINE int f32_ordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_ordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation != softfloat_relation_unordered);
 }
 
 // 0x08
-BX_CPP_INLINE int f32_eq_unordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_eq_unordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation == softfloat_relation_equal) || (relation == softfloat_relation_unordered);
 }
 
 // 0x09
-BX_CPP_INLINE int f32_nge_unordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_nge_unordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_unordered);
 }
 
 // 0x0a
-BX_CPP_INLINE int f32_ngt_unordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_ngt_unordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation != softfloat_relation_greater);
 }
 
 // 0x0b
-BX_CPP_INLINE int f32_false_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_false_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    f32_compare_quiet(a, b, status);
    return 0;
 }
 
 // 0x0c
-BX_CPP_INLINE int f32_neq_ordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_neq_ordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation != softfloat_relation_equal) && (relation != softfloat_relation_unordered);
 }
 
 // 0x0d
-BX_CPP_INLINE int f32_ge_ordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_ge_ordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation == softfloat_relation_greater) || (relation == softfloat_relation_equal);
 }
 
 // 0x0e
-BX_CPP_INLINE int f32_gt_ordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_gt_ordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation == softfloat_relation_greater);
 }
 
 // 0x0f
-BX_CPP_INLINE int f32_true_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_true_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    f32_compare_quiet(a, b, status);
    return 1;
 }
 
 // 0x10
-BX_CPP_INLINE int f32_eq_ordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_eq_ordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation == softfloat_relation_equal);
 }
 
 // 0x11
-BX_CPP_INLINE int f32_lt_ordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_lt_ordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation == softfloat_relation_less);
 }
 
 // 0x12
-BX_CPP_INLINE int f32_le_ordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_le_ordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_equal);
 }
 
 // 0x13
-BX_CPP_INLINE int f32_unordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_unordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation == softfloat_relation_unordered);
 }
 
 // 0x14
-BX_CPP_INLINE int f32_neq_unordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_neq_unordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation != softfloat_relation_equal);
 }
 
 // 0x15
-BX_CPP_INLINE int f32_nlt_unordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_nlt_unordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation != softfloat_relation_less);
 }
 
 // 0x16
-BX_CPP_INLINE int f32_nle_unordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_nle_unordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation != softfloat_relation_less) && (relation != softfloat_relation_equal);
 }
 
 // 0x17
-BX_CPP_INLINE int f32_ordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_ordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation != softfloat_relation_unordered);
 }
 
 // 0x18
-BX_CPP_INLINE int f32_eq_unordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_eq_unordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation == softfloat_relation_equal) || (relation == softfloat_relation_unordered);
 }
 
 // 0x19
-BX_CPP_INLINE int f32_nge_unordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_nge_unordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_unordered);
 }
 
 // 0x1a
-BX_CPP_INLINE int f32_ngt_unordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_ngt_unordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation != softfloat_relation_greater);
 }
 
 // 0x1b
-BX_CPP_INLINE int f32_false_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_false_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    f32_compare(a, b, status);
    return 0;
 }
 
 // 0x1c
-BX_CPP_INLINE int f32_neq_ordered_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_neq_ordered_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare(a, b, status);
    return (relation != softfloat_relation_equal) && (relation != softfloat_relation_unordered);
 }
 
 // 0x1d
-BX_CPP_INLINE int f32_ge_ordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_ge_ordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation == softfloat_relation_greater) || (relation == softfloat_relation_equal);
 }
 
 // 0x1e
-BX_CPP_INLINE int f32_gt_ordered_quiet(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_gt_ordered_quiet(float32 a, float32 b, softfloat_status_t *status)
 {
    int relation = f32_compare_quiet(a, b, status);
    return (relation == softfloat_relation_greater);
 }
 
 // 0x1f
-BX_CPP_INLINE int f32_true_signalling(float32_t a, float32_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f32_true_signalling(float32 a, float32 b, softfloat_status_t *status)
 {
    f32_compare(a, b, status);
    return 1;
@@ -496,227 +496,227 @@ BX_CPP_INLINE int f32_true_signalling(float32_t a, float32_t b, softfloat_status
 
 // ======= float64 ======= //
 
-typedef int (*float64_compare_method)(float64_t, float64_t, softfloat_status_t *status);
+typedef int (*float64_compare_method)(float64, float64, softfloat_status_t *status);
 
 // 0x00
-BX_CPP_INLINE int f64_eq_ordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_eq_ordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation == softfloat_relation_equal);
 }
 
 // 0x01
-BX_CPP_INLINE int f64_lt_ordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_lt_ordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation == softfloat_relation_less);
 }
 
 // 0x02
-BX_CPP_INLINE int f64_le_ordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_le_ordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_equal);
 }
 
 // 0x03
-BX_CPP_INLINE int f64_unordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_unordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation == softfloat_relation_unordered);
 }
 
 // 0x04
-BX_CPP_INLINE int f64_neq_unordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_neq_unordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation != softfloat_relation_equal);
 }
 
 // 0x05
-BX_CPP_INLINE int f64_nlt_unordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_nlt_unordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation != softfloat_relation_less);
 }
 
 // 0x06
-BX_CPP_INLINE int f64_nle_unordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_nle_unordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation != softfloat_relation_less) && (relation != softfloat_relation_equal);
 }
 
 // 0x07
-BX_CPP_INLINE int f64_ordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_ordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation != softfloat_relation_unordered);
 }
 
 // 0x08
-BX_CPP_INLINE int f64_eq_unordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_eq_unordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation == softfloat_relation_equal) || (relation == softfloat_relation_unordered);
 }
 
 // 0x09
-BX_CPP_INLINE int f64_nge_unordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_nge_unordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_unordered);
 }
 
 // 0x0a
-BX_CPP_INLINE int f64_ngt_unordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_ngt_unordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation != softfloat_relation_greater);
 }
 
 // 0x0b
-BX_CPP_INLINE int f64_false_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_false_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    f64_compare_quiet(a, b, status);
    return 0;
 }
 
 // 0x0c
-BX_CPP_INLINE int f64_neq_ordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_neq_ordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation != softfloat_relation_equal) && (relation != softfloat_relation_unordered);
 }
 
 // 0x0d
-BX_CPP_INLINE int f64_ge_ordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_ge_ordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation == softfloat_relation_greater) || (relation == softfloat_relation_equal);
 }
 
 // 0x0e
-BX_CPP_INLINE int f64_gt_ordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_gt_ordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation == softfloat_relation_greater);
 }
 
 // 0x0f
-BX_CPP_INLINE int f64_true_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_true_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    f64_compare_quiet(a, b, status);
    return 1;
 }
 
 // 0x10
-BX_CPP_INLINE int f64_eq_ordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_eq_ordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation == softfloat_relation_equal);
 }
 
 // 0x11
-BX_CPP_INLINE int f64_lt_ordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_lt_ordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation == softfloat_relation_less);
 }
 
 // 0x12
-BX_CPP_INLINE int f64_le_ordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_le_ordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_equal);
 }
 
 // 0x13
-BX_CPP_INLINE int f64_unordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_unordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation == softfloat_relation_unordered);
 }
 
 // 0x14
-BX_CPP_INLINE int f64_neq_unordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_neq_unordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation != softfloat_relation_equal);
 }
 
 // 0x15
-BX_CPP_INLINE int f64_nlt_unordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_nlt_unordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation != softfloat_relation_less);
 }
 
 // 0x16
-BX_CPP_INLINE int f64_nle_unordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_nle_unordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation != softfloat_relation_less) && (relation != softfloat_relation_equal);
 }
 
 // 0x17
-BX_CPP_INLINE int f64_ordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_ordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation != softfloat_relation_unordered);
 }
 
 // 0x18
-BX_CPP_INLINE int f64_eq_unordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_eq_unordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation == softfloat_relation_equal) || (relation == softfloat_relation_unordered);
 }
 
 // 0x19
-BX_CPP_INLINE int f64_nge_unordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_nge_unordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation == softfloat_relation_less) || (relation == softfloat_relation_unordered);
 }
 
 // 0x1a
-BX_CPP_INLINE int f64_ngt_unordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_ngt_unordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation != softfloat_relation_greater);
 }
 
 // 0x1b
-BX_CPP_INLINE int f64_false_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_false_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    f64_compare(a, b, status);
    return 0;
 }
 
 // 0x1c
-BX_CPP_INLINE int f64_neq_ordered_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_neq_ordered_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare(a, b, status);
    return (relation != softfloat_relation_equal) && (relation != softfloat_relation_unordered);
 }
 
 // 0x1d
-BX_CPP_INLINE int f64_ge_ordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_ge_ordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation == softfloat_relation_greater) || (relation == softfloat_relation_equal);
 }
 
 // 0x1e
-BX_CPP_INLINE int f64_gt_ordered_quiet(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_gt_ordered_quiet(float64 a, float64 b, softfloat_status_t *status)
 {
    int relation = f64_compare_quiet(a, b, status);
    return (relation == softfloat_relation_greater);
 }
 
 // 0x1f
-BX_CPP_INLINE int f64_true_signalling(float64_t a, float64_t b, softfloat_status_t *status)
+BX_CPP_INLINE int f64_true_signalling(float64 a, float64 b, softfloat_status_t *status)
 {
    f64_compare(a, b, status);
    return 1;
diff --git a/bochs/cpu/softfloat3e/include/softfloat-extra.h b/bochs/cpu/softfloat3e/include/softfloat-extra.h
index af2b484fc..d0278ac48 100644
--- a/bochs/cpu/softfloat3e/include/softfloat-extra.h
+++ b/bochs/cpu/softfloat3e/include/softfloat-extra.h
@@ -40,22 +40,22 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ======= float16 ======= //
 
-BX_CPP_INLINE bool f16_sign(float16_t a)
+BX_CPP_INLINE bool f16_sign(float16 a)
 {
     return signF16UI(a);
 }
 
-BX_CPP_INLINE int8_t f16_exp(float16_t a)
+BX_CPP_INLINE int8_t f16_exp(float16 a)
 {
     return expF16UI(a);
 }
 
-BX_CPP_INLINE uint16_t f16_fraction(float16_t a)
+BX_CPP_INLINE uint16_t f16_fraction(float16 a)
 {
     return fracF16UI(a);
 }
 
-BX_CPP_INLINE float16_t f16_denormal_to_zero(float16_t a)
+BX_CPP_INLINE float16 f16_denormal_to_zero(float16 a)
 {
     if (! expF16UI(a) && fracF16UI(a))
         return a & 0x8000;
@@ -64,22 +64,22 @@ BX_CPP_INLINE float16_t f16_denormal_to_zero(float16_t a)
 
 // ======= float32 ======= //
 
-BX_CPP_INLINE bool f32_sign(float32_t a)
+BX_CPP_INLINE bool f32_sign(float32 a)
 {
     return signF32UI(a);
 }
 
-BX_CPP_INLINE int16_t f32_exp(float32_t a)
+BX_CPP_INLINE int16_t f32_exp(float32 a)
 {
     return expF32UI(a);
 }
 
-BX_CPP_INLINE uint32_t f32_fraction(float32_t a)
+BX_CPP_INLINE uint32_t f32_fraction(float32 a)
 {
     return fracF32UI(a);
 }
 
-BX_CPP_INLINE float32_t f32_denormal_to_zero(float32_t a)
+BX_CPP_INLINE float32 f32_denormal_to_zero(float32 a)
 {
     if (! expF32UI(a) && fracF32UI(a))
         return a & 0x80000000;
@@ -88,22 +88,22 @@ BX_CPP_INLINE float32_t f32_denormal_to_zero(float32_t a)
 
 // ======= float64 ======= //
 
-BX_CPP_INLINE bool f64_sign(float64_t a)
+BX_CPP_INLINE bool f64_sign(float64 a)
 {
     return signF64UI(a);
 }
 
-BX_CPP_INLINE int16_t f64_exp(float64_t a)
+BX_CPP_INLINE int16_t f64_exp(float64 a)
 {
     return expF64UI(a);
 }
 
-BX_CPP_INLINE uint64_t f64_fraction(float64_t a)
+BX_CPP_INLINE uint64_t f64_fraction(float64 a)
 {
     return fracF64UI(a);
 }
 
-BX_CPP_INLINE float64_t f64_denormal_to_zero(float64_t a)
+BX_CPP_INLINE float64 f64_denormal_to_zero(float64 a)
 {
     if (! expF64UI(a) && fracF64UI(a))
         return a & ((uint64_t)(1) << 63);
diff --git a/bochs/cpu/softfloat3e/include/softfloat.h b/bochs/cpu/softfloat3e/include/softfloat.h
index 471e6a6e7..3e5d6c75e 100644
--- a/bochs/cpu/softfloat3e/include/softfloat.h
+++ b/bochs/cpu/softfloat3e/include/softfloat.h
@@ -210,97 +210,97 @@ BX_CPP_INLINE void softfloat_setRoundingUp(struct softfloat_status_t *status) {
 /*----------------------------------------------------------------------------
 | Integer-to-floating-point conversion routines.
 *----------------------------------------------------------------------------*/
-float16_t ui16_to_f16(uint16_t, struct softfloat_status_t *);
-float16_t ui32_to_f16(uint32_t, struct softfloat_status_t *);
-float32_t ui32_to_f32(uint32_t, struct softfloat_status_t *);
-float64_t ui32_to_f64(uint32_t);
+float16 ui16_to_f16(uint16_t, struct softfloat_status_t *);
+float16 ui32_to_f16(uint32_t, struct softfloat_status_t *);
+float32 ui32_to_f32(uint32_t, struct softfloat_status_t *);
+float64 ui32_to_f64(uint32_t);
 extFloat80_t ui32_to_extF80(uint32_t);
 float128_t ui32_to_f128(uint32_t);
-float16_t ui64_to_f16(uint64_t, struct softfloat_status_t *);
-float32_t ui64_to_f32(uint64_t, struct softfloat_status_t *);
-float64_t ui64_to_f64(uint64_t, struct softfloat_status_t *);
+float16 ui64_to_f16(uint64_t, struct softfloat_status_t *);
+float32 ui64_to_f32(uint64_t, struct softfloat_status_t *);
+float64 ui64_to_f64(uint64_t, struct softfloat_status_t *);
 extFloat80_t ui64_to_extF80(uint64_t);
 float128_t ui64_to_f128(uint64_t);
-float16_t i16_to_f16(int16_t, struct softfloat_status_t *);
-float16_t i32_to_f16(int32_t, struct softfloat_status_t *);
-float32_t i32_to_f32(int32_t, struct softfloat_status_t *);
-float64_t i32_to_f64(int32_t);
+float16 i16_to_f16(int16_t, struct softfloat_status_t *);
+float16 i32_to_f16(int32_t, struct softfloat_status_t *);
+float32 i32_to_f32(int32_t, struct softfloat_status_t *);
+float64 i32_to_f64(int32_t);
 extFloat80_t i32_to_extF80(int32_t);
 float128_t i32_to_f128(int32_t);
-float16_t i64_to_f16(int64_t, struct softfloat_status_t *);
-float32_t i64_to_f32(int64_t, struct softfloat_status_t *);
-float64_t i64_to_f64(int64_t, struct softfloat_status_t *);
+float16 i64_to_f16(int64_t, struct softfloat_status_t *);
+float32 i64_to_f32(int64_t, struct softfloat_status_t *);
+float64 i64_to_f64(int64_t, struct softfloat_status_t *);
 extFloat80_t i64_to_extF80(int64_t);
 float128_t i64_to_f128(int64_t);
 
-BX_CPP_INLINE float16_t i16_to_f16(int16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE float16 i16_to_f16(int16_t a, struct softfloat_status_t *status) {
   return i32_to_f16((int32_t)(a), status);
 }
 
-BX_CPP_INLINE float16_t ui16_to_f16(uint16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE float16 ui16_to_f16(uint16_t a, struct softfloat_status_t *status) {
   return ui32_to_f16((uint32_t)(a), status);
 }
 
 /*----------------------------------------------------------------------------
 | 16-bit (half-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint32_t f16_to_ui32(float16_t, uint8_t, bool, struct softfloat_status_t *);
-uint64_t f16_to_ui64(float16_t, uint8_t, bool, struct softfloat_status_t *);
-int32_t f16_to_i32(float16_t, uint8_t, bool, struct softfloat_status_t *);
-int64_t f16_to_i64(float16_t, uint8_t, bool, struct softfloat_status_t *);
-uint32_t f16_to_ui32_r_minMag(float16_t, bool, struct softfloat_status_t *);
-uint64_t f16_to_ui64_r_minMag(float16_t, bool, struct softfloat_status_t *);
-int32_t f16_to_i32_r_minMag(float16_t, bool, struct softfloat_status_t *);
-int64_t f16_to_i64_r_minMag(float16_t, bool, struct softfloat_status_t *);
-float32_t f16_to_f32(float16_t, struct softfloat_status_t *);
-float64_t f16_to_f64(float16_t, struct softfloat_status_t *);
-extFloat80_t f16_to_extF80(float16_t, struct softfloat_status_t *);
-float16_t f16_roundToInt(float16_t, uint8_t, uint8_t, bool, struct softfloat_status_t *);
-float16_t f16_add(float16_t, float16_t, struct softfloat_status_t *);
-float16_t f16_sub(float16_t, float16_t, struct softfloat_status_t *);
-float16_t f16_mul(float16_t, float16_t, struct softfloat_status_t *);
-float16_t f16_mulAdd(float16_t, float16_t, float16_t, uint8_t op, struct softfloat_status_t *);
-float16_t f16_div(float16_t, float16_t, struct softfloat_status_t *);
-float16_t f16_min(float16_t, float16_t, struct softfloat_status_t *);
-float16_t f16_max(float16_t, float16_t, struct softfloat_status_t *);
-float16_t f16_getExp(float16_t, struct softfloat_status_t *);
-float16_t f16_getMant(float16_t, struct softfloat_status_t *, int, int);
-float16_t f16_range(float16_t, float16_t, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *);
-int f16_compare(float16_t, float16_t, bool, struct softfloat_status_t *);
-float16_t f16_sqrt(float16_t, struct softfloat_status_t *);
-softfloat_class_t f16_class(float16_t);
+uint32_t f16_to_ui32(float16, uint8_t, bool, struct softfloat_status_t *);
+uint64_t f16_to_ui64(float16, uint8_t, bool, struct softfloat_status_t *);
+int32_t f16_to_i32(float16, uint8_t, bool, struct softfloat_status_t *);
+int64_t f16_to_i64(float16, uint8_t, bool, struct softfloat_status_t *);
+uint32_t f16_to_ui32_r_minMag(float16, bool, struct softfloat_status_t *);
+uint64_t f16_to_ui64_r_minMag(float16, bool, struct softfloat_status_t *);
+int32_t f16_to_i32_r_minMag(float16, bool, struct softfloat_status_t *);
+int64_t f16_to_i64_r_minMag(float16, bool, struct softfloat_status_t *);
+float32 f16_to_f32(float16, struct softfloat_status_t *);
+float64 f16_to_f64(float16, struct softfloat_status_t *);
+extFloat80_t f16_to_extF80(float16, struct softfloat_status_t *);
+float16 f16_roundToInt(float16, uint8_t, uint8_t, bool, struct softfloat_status_t *);
+float16 f16_add(float16, float16, struct softfloat_status_t *);
+float16 f16_sub(float16, float16, struct softfloat_status_t *);
+float16 f16_mul(float16, float16, struct softfloat_status_t *);
+float16 f16_mulAdd(float16, float16, float16, uint8_t op, struct softfloat_status_t *);
+float16 f16_div(float16, float16, struct softfloat_status_t *);
+float16 f16_min(float16, float16, struct softfloat_status_t *);
+float16 f16_max(float16, float16, struct softfloat_status_t *);
+float16 f16_getExp(float16, struct softfloat_status_t *);
+float16 f16_getMant(float16, struct softfloat_status_t *, int, int);
+float16 f16_range(float16, float16, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *);
+int f16_compare(float16, float16, bool, struct softfloat_status_t *);
+float16 f16_sqrt(float16, struct softfloat_status_t *);
+softfloat_class_t f16_class(float16);
 
-bool f16_isSignalingNaN(float16_t);
-bool f16_isNaN(float16_t);
+bool f16_isSignalingNaN(float16);
+bool f16_isNaN(float16);
 
-bool f16_sign(float16_t);
-int8_t f16_exp(float16_t);
-uint16_t f16_fraction(float16_t);
-float16_t f16_denormal_to_zero(float16_t);
+bool f16_sign(float16);
+int8_t f16_exp(float16);
+uint16_t f16_fraction(float16);
+float16 f16_denormal_to_zero(float16);
 
-BX_CPP_INLINE int f16_compare(float16_t a, float16_t b, softfloat_status_t *status) {
+BX_CPP_INLINE int f16_compare(float16 a, float16 b, softfloat_status_t *status) {
   return f16_compare(a, b, 0, status);
 }
 
-BX_CPP_INLINE int f16_compare_quiet(float16_t a, float16_t b, softfloat_status_t *status) {
+BX_CPP_INLINE int f16_compare_quiet(float16 a, float16 b, softfloat_status_t *status) {
   return f16_compare(a, b, 1, status);
 }
 
-BX_CPP_INLINE float16_t f16_roundToInt(float16_t a, uint8_t scale, struct softfloat_status_t *status) {
+BX_CPP_INLINE float16 f16_roundToInt(float16 a, uint8_t scale, struct softfloat_status_t *status) {
     return f16_roundToInt(a, scale, softfloat_getRoundingMode(status), true, status);
 }
-BX_CPP_INLINE float16_t f16_roundToInt(float16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE float16 f16_roundToInt(float16 a, struct softfloat_status_t *status) {
     return f16_roundToInt(a, 0, softfloat_getRoundingMode(status), true, status);
 }
 
-BX_CPP_INLINE int64_t f16_to_i64(float16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int64_t f16_to_i64(float16 a, struct softfloat_status_t *status) {
     return f16_to_i64(a, softfloat_getRoundingMode(status), true, status);
 }
-BX_CPP_INLINE int32_t f16_to_i32(float16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int32_t f16_to_i32(float16 a, struct softfloat_status_t *status) {
     return f16_to_i32(a, softfloat_getRoundingMode(status), true, status);
 }
 
-BX_CPP_INLINE int16_t f16_to_i16(float16_t a, softfloat_status_t *status)
+BX_CPP_INLINE int16_t f16_to_i16(float16 a, softfloat_status_t *status)
 {
     int32_t val_32 = f16_to_i32(a, status);
     int16_t val_16 = (int16_t) val_32;
@@ -311,14 +311,14 @@ BX_CPP_INLINE int16_t f16_to_i16(float16_t a, softfloat_status_t *status)
     return val_16;
 }
 
-BX_CPP_INLINE int64_t f16_to_i64_round_to_zero(float16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int64_t f16_to_i64_round_to_zero(float16 a, struct softfloat_status_t *status) {
     return f16_to_i64_r_minMag(a, true, status);
 }
-BX_CPP_INLINE int32_t f16_to_i32_round_to_zero(float16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int32_t f16_to_i32_round_to_zero(float16 a, struct softfloat_status_t *status) {
     return f16_to_i32_r_minMag(a, true, status);
 }
 
-BX_CPP_INLINE int16_t f16_to_i16_round_to_zero(float16_t a, softfloat_status_t *status)
+BX_CPP_INLINE int16_t f16_to_i16_round_to_zero(float16 a, softfloat_status_t *status)
 {
     int32_t val_32 = f16_to_i32_round_to_zero(a, status);
     int16_t val_16 = (int16_t) val_32;
@@ -329,14 +329,14 @@ BX_CPP_INLINE int16_t f16_to_i16_round_to_zero(float16_t a, softfloat_status_t *
     return val_16;
 }
 
-BX_CPP_INLINE uint64_t f16_to_ui64(float16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint64_t f16_to_ui64(float16 a, struct softfloat_status_t *status) {
     return f16_to_ui64(a, softfloat_getRoundingMode(status), true, status);
 }
-BX_CPP_INLINE uint32_t f16_to_ui32(float16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint32_t f16_to_ui32(float16 a, struct softfloat_status_t *status) {
     return f16_to_ui32(a, softfloat_getRoundingMode(status), true, status);
 }
 
-BX_CPP_INLINE uint16_t f16_to_ui16(float16_t a, softfloat_status_t *status)
+BX_CPP_INLINE uint16_t f16_to_ui16(float16 a, softfloat_status_t *status)
 {
     uint32_t val_32 = f16_to_ui32(a, status);
     if (val_32 > 0xFFFF) {
@@ -346,14 +346,14 @@ BX_CPP_INLINE uint16_t f16_to_ui16(float16_t a, softfloat_status_t *status)
     return (uint16_t) val_32;
 }
 
-BX_CPP_INLINE uint64_t f16_to_ui64_round_to_zero(float16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint64_t f16_to_ui64_round_to_zero(float16 a, struct softfloat_status_t *status) {
     return f16_to_ui64_r_minMag(a, true, status);
 }
-BX_CPP_INLINE uint32_t f16_to_ui32_round_to_zero(float16_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint32_t f16_to_ui32_round_to_zero(float16 a, struct softfloat_status_t *status) {
     return f16_to_ui32_r_minMag(a, true, status);
 }
 
-BX_CPP_INLINE uint16_t f16_to_ui16_round_to_zero(float16_t a, softfloat_status_t *status)
+BX_CPP_INLINE uint16_t f16_to_ui16_round_to_zero(float16 a, softfloat_status_t *status)
 {
     uint32_t val_32 = f16_to_ui32_round_to_zero(a, status);
     if (val_32 > 0xFFFF) {
@@ -363,208 +363,208 @@ BX_CPP_INLINE uint16_t f16_to_ui16_round_to_zero(float16_t a, softfloat_status_t
     return (uint16_t) val_32;
 }
 
-BX_CPP_INLINE float16_t f16_fmadd(float16_t a, float16_t b, float16_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float16 f16_fmadd(float16 a, float16 b, float16 c, softfloat_status_t *status) {
     return f16_mulAdd(a, b, c, 0, status);
 }
-BX_CPP_INLINE float16_t f16_fmsub(float16_t a, float16_t b, float16_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float16 f16_fmsub(float16 a, float16 b, float16 c, softfloat_status_t *status) {
     return f16_mulAdd(a, b, c, softfloat_muladd_negate_c, status);
 }
-BX_CPP_INLINE float16_t f16_fnmadd(float16_t a, float16_t b, float16_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float16 f16_fnmadd(float16 a, float16 b, float16 c, softfloat_status_t *status) {
     return f16_mulAdd(a, b, c, softfloat_muladd_negate_product, status);
 }
-BX_CPP_INLINE float16_t f16_fnmsub(float16_t a, float16_t b, float16_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float16 f16_fnmsub(float16 a, float16 b, float16 c, softfloat_status_t *status) {
     return f16_mulAdd(a, b, c, softfloat_muladd_negate_result, status);
 }
 
 /*----------------------------------------------------------------------------
 | 32-bit (single-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint32_t f32_to_ui32(float32_t, uint8_t, bool, struct softfloat_status_t *);
-uint64_t f32_to_ui64(float32_t, uint8_t, bool, struct softfloat_status_t *);
-int32_t f32_to_i32(float32_t, uint8_t, bool, struct softfloat_status_t *);
-int64_t f32_to_i64(float32_t, uint8_t, bool, struct softfloat_status_t *);
-uint32_t f32_to_ui32_r_minMag(float32_t, bool, struct softfloat_status_t *);
-uint64_t f32_to_ui64_r_minMag(float32_t, bool, struct softfloat_status_t *);
-int32_t f32_to_i32_r_minMag(float32_t, bool, struct softfloat_status_t *);
-int64_t f32_to_i64_r_minMag(float32_t, bool, struct softfloat_status_t *);
-float16_t f32_to_f16(float32_t, struct softfloat_status_t *);
-float64_t f32_to_f64(float32_t, struct softfloat_status_t *);
-extFloat80_t f32_to_extF80(float32_t, struct softfloat_status_t *);
-float128_t f32_to_f128(float32_t, struct softfloat_status_t *);
-float32_t f32_roundToInt(float32_t, uint8_t, uint8_t, bool, struct softfloat_status_t *);
-float32_t f32_add(float32_t, float32_t, struct softfloat_status_t *);
-float32_t f32_sub(float32_t, float32_t, struct softfloat_status_t *);
-float32_t f32_mul(float32_t, float32_t, struct softfloat_status_t *);
-float32_t f32_mulAdd(float32_t, float32_t, float32_t, uint8_t op, struct softfloat_status_t *);
-float32_t f32_div(float32_t, float32_t, struct softfloat_status_t *);
-float32_t f32_min(float32_t, float32_t, struct softfloat_status_t *);
-float32_t f32_max(float32_t, float32_t, struct softfloat_status_t *);
-float32_t f32_scalef(float32_t, float32_t, struct softfloat_status_t *);
-float32_t f32_getExp(float32_t, struct softfloat_status_t *);
-float32_t f32_getMant(float32_t, struct softfloat_status_t *, int, int);
-float32_t f32_range(float32_t, float32_t, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *);
-float32_t f32_frc(float32_t, struct softfloat_status_t *);
-int f32_compare(float32_t, float32_t, bool, struct softfloat_status_t *);
-float32_t f32_sqrt(float32_t, struct softfloat_status_t *);
-softfloat_class_t f32_class(float32_t);
+uint32_t f32_to_ui32(float32, uint8_t, bool, struct softfloat_status_t *);
+uint64_t f32_to_ui64(float32, uint8_t, bool, struct softfloat_status_t *);
+int32_t f32_to_i32(float32, uint8_t, bool, struct softfloat_status_t *);
+int64_t f32_to_i64(float32, uint8_t, bool, struct softfloat_status_t *);
+uint32_t f32_to_ui32_r_minMag(float32, bool, struct softfloat_status_t *);
+uint64_t f32_to_ui64_r_minMag(float32, bool, struct softfloat_status_t *);
+int32_t f32_to_i32_r_minMag(float32, bool, struct softfloat_status_t *);
+int64_t f32_to_i64_r_minMag(float32, bool, struct softfloat_status_t *);
+float16 f32_to_f16(float32, struct softfloat_status_t *);
+float64 f32_to_f64(float32, struct softfloat_status_t *);
+extFloat80_t f32_to_extF80(float32, struct softfloat_status_t *);
+float128_t f32_to_f128(float32, struct softfloat_status_t *);
+float32 f32_roundToInt(float32, uint8_t, uint8_t, bool, struct softfloat_status_t *);
+float32 f32_add(float32, float32, struct softfloat_status_t *);
+float32 f32_sub(float32, float32, struct softfloat_status_t *);
+float32 f32_mul(float32, float32, struct softfloat_status_t *);
+float32 f32_mulAdd(float32, float32, float32, uint8_t op, struct softfloat_status_t *);
+float32 f32_div(float32, float32, struct softfloat_status_t *);
+float32 f32_min(float32, float32, struct softfloat_status_t *);
+float32 f32_max(float32, float32, struct softfloat_status_t *);
+float32 f32_scalef(float32, float32, struct softfloat_status_t *);
+float32 f32_getExp(float32, struct softfloat_status_t *);
+float32 f32_getMant(float32, struct softfloat_status_t *, int, int);
+float32 f32_range(float32, float32, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *);
+float32 f32_frc(float32, struct softfloat_status_t *);
+int f32_compare(float32, float32, bool, struct softfloat_status_t *);
+float32 f32_sqrt(float32, struct softfloat_status_t *);
+softfloat_class_t f32_class(float32);
 
-bool f32_isSignalingNaN(float32_t);
-bool f32_isNaN(float32_t);
+bool f32_isSignalingNaN(float32);
+bool f32_isNaN(float32);
 
-bool f32_sign(float32_t);
-int16_t f32_exp(float32_t);
-uint32_t f32_fraction(float32_t);
-float32_t f32_denormal_to_zero(float32_t);
+bool f32_sign(float32);
+int16_t f32_exp(float32);
+uint32_t f32_fraction(float32);
+float32 f32_denormal_to_zero(float32);
 
-BX_CPP_INLINE int f32_compare(float32_t a, float32_t b, softfloat_status_t *status) {
+BX_CPP_INLINE int f32_compare(float32 a, float32 b, softfloat_status_t *status) {
     return f32_compare(a, b, 0, status);
 }
 
-BX_CPP_INLINE int f32_compare_quiet(float32_t a, float32_t b, softfloat_status_t *status) {
+BX_CPP_INLINE int f32_compare_quiet(float32 a, float32 b, softfloat_status_t *status) {
     return f32_compare(a, b, 1, status);
 }
 
-BX_CPP_INLINE float32_t f32_roundToInt(float32_t a, uint8_t scale, struct softfloat_status_t *status) {
+BX_CPP_INLINE float32 f32_roundToInt(float32 a, uint8_t scale, struct softfloat_status_t *status) {
     return f32_roundToInt(a, scale, softfloat_getRoundingMode(status), true, status);
 }
-BX_CPP_INLINE float32_t f32_roundToInt(float32_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE float32 f32_roundToInt(float32 a, struct softfloat_status_t *status) {
     return f32_roundToInt(a, 0, softfloat_getRoundingMode(status), true, status);
 }
 
-BX_CPP_INLINE int32_t f32_to_i32(float32_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int32_t f32_to_i32(float32 a, struct softfloat_status_t *status) {
     return f32_to_i32(a, softfloat_getRoundingMode(status), true, status);
 }
-BX_CPP_INLINE int64_t f32_to_i64(float32_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int64_t f32_to_i64(float32 a, struct softfloat_status_t *status) {
     return f32_to_i64(a, softfloat_getRoundingMode(status), true, status);
 }
 
-BX_CPP_INLINE int32_t f32_to_i32_round_to_zero(float32_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int32_t f32_to_i32_round_to_zero(float32 a, struct softfloat_status_t *status) {
     return f32_to_i32_r_minMag(a, true, status);
 }
-BX_CPP_INLINE int64_t f32_to_i64_round_to_zero(float32_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int64_t f32_to_i64_round_to_zero(float32 a, struct softfloat_status_t *status) {
     return f32_to_i64_r_minMag(a, true, status);
 }
 
-BX_CPP_INLINE uint32_t f32_to_ui32(float32_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint32_t f32_to_ui32(float32 a, struct softfloat_status_t *status) {
     return f32_to_ui32(a, softfloat_getRoundingMode(status), true, status);
 }
-BX_CPP_INLINE uint64_t f32_to_ui64(float32_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint64_t f32_to_ui64(float32 a, struct softfloat_status_t *status) {
     return f32_to_ui64(a, softfloat_getRoundingMode(status), true, status);
 }
 
-BX_CPP_INLINE uint32_t f32_to_ui32_round_to_zero(float32_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint32_t f32_to_ui32_round_to_zero(float32 a, struct softfloat_status_t *status) {
     return f32_to_ui32_r_minMag(a, true, status);
 }
-BX_CPP_INLINE uint64_t f32_to_ui64_round_to_zero(float32_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint64_t f32_to_ui64_round_to_zero(float32 a, struct softfloat_status_t *status) {
     return f32_to_ui64_r_minMag(a, true, status);
 }
 
-BX_CPP_INLINE float32_t f32_fmadd(float32_t a, float32_t b, float32_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float32 f32_fmadd(float32 a, float32 b, float32 c, softfloat_status_t *status) {
     return f32_mulAdd(a, b, c, 0, status);
 }
-BX_CPP_INLINE float32_t f32_fmsub(float32_t a, float32_t b, float32_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float32 f32_fmsub(float32 a, float32 b, float32 c, softfloat_status_t *status) {
     return f32_mulAdd(a, b, c, softfloat_muladd_negate_c, status);
 }
-BX_CPP_INLINE float32_t f32_fnmadd(float32_t a, float32_t b, float32_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float32 f32_fnmadd(float32 a, float32 b, float32 c, softfloat_status_t *status) {
     return f32_mulAdd(a, b, c, softfloat_muladd_negate_product, status);
 }
-BX_CPP_INLINE float32_t f32_fnmsub(float32_t a, float32_t b, float32_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float32 f32_fnmsub(float32 a, float32 b, float32 c, softfloat_status_t *status) {
     return f32_mulAdd(a, b, c, softfloat_muladd_negate_result, status);
 }
 
 /*----------------------------------------------------------------------------
 | 64-bit (double-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint32_t f64_to_ui32(float64_t, uint8_t, bool, struct softfloat_status_t *);
-uint64_t f64_to_ui64(float64_t, uint8_t, bool, struct softfloat_status_t *);
-int32_t f64_to_i32(float64_t, uint8_t, bool, struct softfloat_status_t *);
-int64_t f64_to_i64(float64_t, uint8_t, bool, struct softfloat_status_t *);
-uint32_t f64_to_ui32_r_minMag(float64_t, bool, struct softfloat_status_t *);
-uint64_t f64_to_ui64_r_minMag(float64_t, bool, struct softfloat_status_t *);
-int32_t f64_to_i32_r_minMag(float64_t, bool, struct softfloat_status_t *);
-int64_t f64_to_i64_r_minMag(float64_t, bool, struct softfloat_status_t *);
-float16_t f64_to_f16(float64_t, struct softfloat_status_t *);
-float32_t f64_to_f32(float64_t, struct softfloat_status_t *);
-extFloat80_t f64_to_extF80(float64_t, struct softfloat_status_t *);
-float128_t f64_to_f128(float64_t, struct softfloat_status_t *);
-float64_t f64_roundToInt(float64_t, uint8_t, uint8_t, bool, struct softfloat_status_t *);
-float64_t f64_add(float64_t, float64_t, struct softfloat_status_t *);
-float64_t f64_sub(float64_t, float64_t, struct softfloat_status_t *);
-float64_t f64_mul(float64_t, float64_t, struct softfloat_status_t *);
-float64_t f64_mulAdd(float64_t, float64_t, float64_t, uint8_t op, struct softfloat_status_t *);
-float64_t f64_div(float64_t, float64_t, struct softfloat_status_t *);
-float64_t f64_min(float64_t, float64_t, struct softfloat_status_t *);
-float64_t f64_max(float64_t, float64_t, struct softfloat_status_t *);
-float64_t f64_scalef(float64_t, float64_t, struct softfloat_status_t *);
-float64_t f64_getExp(float64_t, struct softfloat_status_t *);
-float64_t f64_getMant(float64_t, struct softfloat_status_t *, int, int);
-float64_t f64_range(float64_t, float64_t, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *);
-float64_t f64_frc(float64_t, struct softfloat_status_t *);
-int f64_compare(float64_t, float64_t, bool, struct softfloat_status_t *);
-float64_t f64_sqrt(float64_t, struct softfloat_status_t *);
-softfloat_class_t f64_class(float64_t);
+uint32_t f64_to_ui32(float64, uint8_t, bool, struct softfloat_status_t *);
+uint64_t f64_to_ui64(float64, uint8_t, bool, struct softfloat_status_t *);
+int32_t f64_to_i32(float64, uint8_t, bool, struct softfloat_status_t *);
+int64_t f64_to_i64(float64, uint8_t, bool, struct softfloat_status_t *);
+uint32_t f64_to_ui32_r_minMag(float64, bool, struct softfloat_status_t *);
+uint64_t f64_to_ui64_r_minMag(float64, bool, struct softfloat_status_t *);
+int32_t f64_to_i32_r_minMag(float64, bool, struct softfloat_status_t *);
+int64_t f64_to_i64_r_minMag(float64, bool, struct softfloat_status_t *);
+float16 f64_to_f16(float64, struct softfloat_status_t *);
+float32 f64_to_f32(float64, struct softfloat_status_t *);
+extFloat80_t f64_to_extF80(float64, struct softfloat_status_t *);
+float128_t f64_to_f128(float64, struct softfloat_status_t *);
+float64 f64_roundToInt(float64, uint8_t, uint8_t, bool, struct softfloat_status_t *);
+float64 f64_add(float64, float64, struct softfloat_status_t *);
+float64 f64_sub(float64, float64, struct softfloat_status_t *);
+float64 f64_mul(float64, float64, struct softfloat_status_t *);
+float64 f64_mulAdd(float64, float64, float64, uint8_t op, struct softfloat_status_t *);
+float64 f64_div(float64, float64, struct softfloat_status_t *);
+float64 f64_min(float64, float64, struct softfloat_status_t *);
+float64 f64_max(float64, float64, struct softfloat_status_t *);
+float64 f64_scalef(float64, float64, struct softfloat_status_t *);
+float64 f64_getExp(float64, struct softfloat_status_t *);
+float64 f64_getMant(float64, struct softfloat_status_t *, int, int);
+float64 f64_range(float64, float64, bool is_max, bool is_abs, int sign_ctrl, softfloat_status_t *);
+float64 f64_frc(float64, struct softfloat_status_t *);
+int f64_compare(float64, float64, bool, struct softfloat_status_t *);
+float64 f64_sqrt(float64, struct softfloat_status_t *);
+softfloat_class_t f64_class(float64);
 
-bool f64_isSignalingNaN(float64_t);
-bool f64_isNaN(float64_t);
+bool f64_isSignalingNaN(float64);
+bool f64_isNaN(float64);
 
-bool f64_sign(float64_t);
-int16_t f64_exp(float64_t);
-uint64_t f64_fraction(float64_t);
-float64_t f64_denormal_to_zero(float64_t);
+bool f64_sign(float64);
+int16_t f64_exp(float64);
+uint64_t f64_fraction(float64);
+float64 f64_denormal_to_zero(float64);
 
-BX_CPP_INLINE int f64_compare(float64_t a, float64_t b, softfloat_status_t *status) {
+BX_CPP_INLINE int f64_compare(float64 a, float64 b, softfloat_status_t *status) {
     return f64_compare(a, b, 0, status);
 }
 
-BX_CPP_INLINE int f64_compare_quiet(float64_t a, float64_t b, softfloat_status_t *status) {
+BX_CPP_INLINE int f64_compare_quiet(float64 a, float64 b, softfloat_status_t *status) {
     return f64_compare(a, b, 1, status);
 }
 
-BX_CPP_INLINE float64_t f64_roundToInt(float64_t a, uint8_t scale, struct softfloat_status_t *status) {
+BX_CPP_INLINE float64 f64_roundToInt(float64 a, uint8_t scale, struct softfloat_status_t *status) {
     return f64_roundToInt(a, scale, softfloat_getRoundingMode(status), true, status);
 }
-BX_CPP_INLINE float64_t f64_roundToInt(float64_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE float64 f64_roundToInt(float64 a, struct softfloat_status_t *status) {
     return f64_roundToInt(a, 0, softfloat_getRoundingMode(status), true, status);
 }
 
-BX_CPP_INLINE int32_t f64_to_i32(float64_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int32_t f64_to_i32(float64 a, struct softfloat_status_t *status) {
     return f64_to_i32(a, softfloat_getRoundingMode(status), true, status);
 }
-BX_CPP_INLINE int64_t f64_to_i64(float64_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int64_t f64_to_i64(float64 a, struct softfloat_status_t *status) {
     return f64_to_i64(a, softfloat_getRoundingMode(status), true, status);
 }
 
-BX_CPP_INLINE int32_t f64_to_i32_round_to_zero(float64_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int32_t f64_to_i32_round_to_zero(float64 a, struct softfloat_status_t *status) {
     return f64_to_i32_r_minMag(a, true, status);
 }
-BX_CPP_INLINE int64_t f64_to_i64_round_to_zero(float64_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE int64_t f64_to_i64_round_to_zero(float64 a, struct softfloat_status_t *status) {
     return f64_to_i64_r_minMag(a, true, status);
 }
 
-BX_CPP_INLINE uint32_t f64_to_ui32(float64_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint32_t f64_to_ui32(float64 a, struct softfloat_status_t *status) {
     return f64_to_ui32(a, softfloat_getRoundingMode(status), true, status);
 }
-BX_CPP_INLINE uint64_t f64_to_ui64(float64_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint64_t f64_to_ui64(float64 a, struct softfloat_status_t *status) {
     return f64_to_ui64(a, softfloat_getRoundingMode(status), true, status);
 }
 
-BX_CPP_INLINE uint32_t f64_to_ui32_round_to_zero(float64_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint32_t f64_to_ui32_round_to_zero(float64 a, struct softfloat_status_t *status) {
     return f64_to_ui32_r_minMag(a, true, status);
 }
-BX_CPP_INLINE uint64_t f64_to_ui64_round_to_zero(float64_t a, struct softfloat_status_t *status) {
+BX_CPP_INLINE uint64_t f64_to_ui64_round_to_zero(float64 a, struct softfloat_status_t *status) {
     return f64_to_ui64_r_minMag(a, true, status);
 }
 
-BX_CPP_INLINE float64_t f64_fmadd(float64_t a, float64_t b, float64_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float64 f64_fmadd(float64 a, float64 b, float64 c, softfloat_status_t *status) {
     return f64_mulAdd(a, b, c, 0, status);
 }
-BX_CPP_INLINE float64_t f64_fmsub(float64_t a, float64_t b, float64_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float64 f64_fmsub(float64 a, float64 b, float64 c, softfloat_status_t *status) {
     return f64_mulAdd(a, b, c, softfloat_muladd_negate_c, status);
 }
-BX_CPP_INLINE float64_t f64_fnmadd(float64_t a, float64_t b, float64_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float64 f64_fnmadd(float64 a, float64 b, float64 c, softfloat_status_t *status) {
     return f64_mulAdd(a, b, c, softfloat_muladd_negate_product, status);
 }
-BX_CPP_INLINE float64_t f64_fnmsub(float64_t a, float64_t b, float64_t c, softfloat_status_t *status) {
+BX_CPP_INLINE float64 f64_fnmsub(float64 a, float64 b, float64 c, softfloat_status_t *status) {
     return f64_mulAdd(a, b, c, softfloat_muladd_negate_result, status);
 }
 
@@ -579,9 +579,9 @@ uint32_t extF80_to_ui32_r_minMag(extFloat80_t, bool, struct softfloat_status_t *
 uint64_t extF80_to_ui64_r_minMag(extFloat80_t, bool, struct softfloat_status_t *);
 int32_t extF80_to_i32_r_minMag(extFloat80_t, bool, struct softfloat_status_t *);
 int64_t extF80_to_i64_r_minMag(extFloat80_t, bool, struct softfloat_status_t *);
-float16_t extF80_to_f16(extFloat80_t, struct softfloat_status_t *);
-float32_t extF80_to_f32(extFloat80_t, struct softfloat_status_t *);
-float64_t extF80_to_f64(extFloat80_t, struct softfloat_status_t *);
+float16 extF80_to_f16(extFloat80_t, struct softfloat_status_t *);
+float32 extF80_to_f32(extFloat80_t, struct softfloat_status_t *);
+float64 extF80_to_f64(extFloat80_t, struct softfloat_status_t *);
 float128_t extF80_to_f128(extFloat80_t, struct softfloat_status_t *);
 extFloat80_t extF80_roundToInt(extFloat80_t, uint8_t, bool, struct softfloat_status_t *);
 extFloat80_t extF80_add(extFloat80_t, extFloat80_t, struct softfloat_status_t *);
@@ -649,9 +649,9 @@ bool extF80_isUnsupported(extFloat80_t);
 bool extF80_isSignalingNaN(extFloat80_t);
 bool extF80_isNaN(extFloat80_t);
 
-bool extF80_sign(float64_t);
-int16_t extF80_exp(float64_t);
-uint64_t extF80_fraction(float64_t);
+bool extF80_sign(float64);
+int16_t extF80_exp(float64);
+uint64_t extF80_fraction(float64);
 
 /*----------------------------------------------------------------------------
 | 128-bit (quadruple-precision) floating-point operations.
@@ -664,8 +664,8 @@ uint32_t f128_to_ui32_r_minMag(float128_t, bool, struct softfloat_status_t *);
 uint64_t f128_to_ui64_r_minMag(float128_t, bool, struct softfloat_status_t *);
 int32_t f128_to_i32_r_minMag(float128_t, bool, struct softfloat_status_t *);
 int64_t f128_to_i64_r_minMag(float128_t, bool, struct softfloat_status_t *);
-float32_t f128_to_f32(float128_t, struct softfloat_status_t *);
-float64_t f128_to_f64(float128_t, struct softfloat_status_t *);
+float32 f128_to_f32(float128_t, struct softfloat_status_t *);
+float64 f128_to_f64(float128_t, struct softfloat_status_t *);
 extFloat80_t f128_to_extF80(float128_t, struct softfloat_status_t *);
 float128_t f128_roundToInt(float128_t, uint8_t, bool, struct softfloat_status_t *);
 float128_t f128_add(float128_t, float128_t, struct softfloat_status_t *);
diff --git a/bochs/cpu/softfloat3e/include/softfloat_types.h b/bochs/cpu/softfloat3e/include/softfloat_types.h
index 9137f5690..5d4b9dd48 100644
--- a/bochs/cpu/softfloat3e/include/softfloat_types.h
+++ b/bochs/cpu/softfloat3e/include/softfloat_types.h
@@ -61,23 +61,29 @@ struct uint128_extra { struct uint128 v; uint64_t extra; };
 | arguments and results to/from functions.  These types must be exactly
 | 16 bits, 32 bits, 64 bits, and 128 bits in size, respectively.
 *----------------------------------------------------------------------------*/
-typedef struct f16_t {
+struct f16_t {
     uint16_t v;
+#ifdef __cplusplus
     f16_t(uint64_t v16): v(v16) {}
     operator uint16_t() const { return v; }
-} float16_t;
+#endif
+};
 
-typedef struct f32_t {
+struct f32_t {
     uint32_t v;
+#ifdef __cplusplus
     f32_t(uint64_t v32): v(v32) {}
     operator uint32_t() const { return v; }
-} float32_t;
+#endif
+};
 
-typedef struct f64_t {
+struct f64_t {
     uint64_t v;
+#ifdef __cplusplus
     f64_t(uint64_t v64): v(v64) {}
     operator uint64_t() const { return v; }
-} float64_t;
+#endif
+};
 
 typedef uint128 float128_t;
 
diff --git a/bochs/cpu/softfloat3e/isNaN.c b/bochs/cpu/softfloat3e/isNaN.c
index c10014d04..895d76f7c 100644
--- a/bochs/cpu/softfloat3e/isNaN.c
+++ b/bochs/cpu/softfloat3e/isNaN.c
@@ -38,17 +38,17 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f16_isNaN(float16_t a)
+bool f16_isNaN(float16 a)
 {
     return isNaNF16UI(a);
 }
 
-bool f32_isNaN(float32_t a)
+bool f32_isNaN(float32 a)
 {
     return isNaNF32UI(a);
 }
 
-bool f64_isNaN(float64_t a)
+bool f64_isNaN(float64 a)
 {
     return isNaNF64UI(a);
 }
diff --git a/bochs/cpu/softfloat3e/isSignalingNaN.c b/bochs/cpu/softfloat3e/isSignalingNaN.c
index 4e0a58acc..fc9b008bf 100644
--- a/bochs/cpu/softfloat3e/isSignalingNaN.c
+++ b/bochs/cpu/softfloat3e/isSignalingNaN.c
@@ -38,17 +38,17 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-bool f16_isSignalingNaN(float16_t a)
+bool f16_isSignalingNaN(float16 a)
 {
     return softfloat_isSigNaNF16UI(a);
 }
 
-bool f32_isSignalingNaN(float32_t a)
+bool f32_isSignalingNaN(float32 a)
 {
     return softfloat_isSigNaNF32UI(a);
 }
 
-bool f64_isSignalingNaN(float64_t a)
+bool f64_isSignalingNaN(float64 a)
 {
     return softfloat_isSigNaNF64UI(a);
 }
diff --git a/bochs/cpu/softfloat3e/s_addMagsF16.c b/bochs/cpu/softfloat3e/s_addMagsF16.c
index 00835b902..022f254a8 100644
--- a/bochs/cpu/softfloat3e/s_addMagsF16.c
+++ b/bochs/cpu/softfloat3e/s_addMagsF16.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t softfloat_addMagsF16(uint16_t uiA, uint16_t uiB, struct softfloat_status_t *status)
+float16 softfloat_addMagsF16(uint16_t uiA, uint16_t uiB, struct softfloat_status_t *status)
 {
     int8_t expA;
     uint16_t sigA;
diff --git a/bochs/cpu/softfloat3e/s_addMagsF32.c b/bochs/cpu/softfloat3e/s_addMagsF32.c
index 6e1801a89..df902348a 100644
--- a/bochs/cpu/softfloat3e/s_addMagsF32.c
+++ b/bochs/cpu/softfloat3e/s_addMagsF32.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "specialize.h"
 
-float32_t softfloat_addMagsF32(uint32_t uiA, uint32_t uiB, struct softfloat_status_t *status)
+float32 softfloat_addMagsF32(uint32_t uiA, uint32_t uiB, struct softfloat_status_t *status)
 {
     int16_t expA;
     uint32_t sigA;
diff --git a/bochs/cpu/softfloat3e/s_addMagsF64.c b/bochs/cpu/softfloat3e/s_addMagsF64.c
index bc4711259..a315860f6 100644
--- a/bochs/cpu/softfloat3e/s_addMagsF64.c
+++ b/bochs/cpu/softfloat3e/s_addMagsF64.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "specialize.h"
 
-float64_t softfloat_addMagsF64(uint64_t uiA, uint64_t uiB, bool signZ, struct softfloat_status_t *status)
+float64 softfloat_addMagsF64(uint64_t uiA, uint64_t uiB, bool signZ, struct softfloat_status_t *status)
 {
     int16_t expA;
     uint64_t sigA;
diff --git a/bochs/cpu/softfloat3e/s_normRoundPackToF16.c b/bochs/cpu/softfloat3e/s_normRoundPackToF16.c
index 57c87fc97..0f11ece8d 100644
--- a/bochs/cpu/softfloat3e/s_normRoundPackToF16.c
+++ b/bochs/cpu/softfloat3e/s_normRoundPackToF16.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "primitives.h"
 
-float16_t softfloat_normRoundPackToF16(bool sign, int16_t exp, uint16_t sig, struct softfloat_status_t *status)
+float16 softfloat_normRoundPackToF16(bool sign, int16_t exp, uint16_t sig, struct softfloat_status_t *status)
 {
     int8_t shiftDist = softfloat_countLeadingZeros16(sig) - 1;
     exp -= shiftDist;
diff --git a/bochs/cpu/softfloat3e/s_normRoundPackToF32.c b/bochs/cpu/softfloat3e/s_normRoundPackToF32.c
index a34e93f66..511e8d195 100644
--- a/bochs/cpu/softfloat3e/s_normRoundPackToF32.c
+++ b/bochs/cpu/softfloat3e/s_normRoundPackToF32.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "primitives.h"
 
-float32_t softfloat_normRoundPackToF32(bool sign, int16_t exp, uint32_t sig, struct softfloat_status_t *status)
+float32 softfloat_normRoundPackToF32(bool sign, int16_t exp, uint32_t sig, struct softfloat_status_t *status)
 {
     int8_t shiftDist = softfloat_countLeadingZeros32(sig) - 1;
     exp -= shiftDist;
diff --git a/bochs/cpu/softfloat3e/s_normRoundPackToF64.c b/bochs/cpu/softfloat3e/s_normRoundPackToF64.c
index 87ce94e1e..eefabc598 100644
--- a/bochs/cpu/softfloat3e/s_normRoundPackToF64.c
+++ b/bochs/cpu/softfloat3e/s_normRoundPackToF64.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "primitives.h"
 
-float64_t softfloat_normRoundPackToF64(bool sign, int16_t exp, uint64_t sig, struct softfloat_status_t *status)
+float64 softfloat_normRoundPackToF64(bool sign, int16_t exp, uint64_t sig, struct softfloat_status_t *status)
 {
     int8_t shiftDist = softfloat_countLeadingZeros64(sig) - 1;
     exp -= shiftDist;
diff --git a/bochs/cpu/softfloat3e/s_roundPackToF16.c b/bochs/cpu/softfloat3e/s_roundPackToF16.c
index 90fd1a8ea..1b9bb178a 100644
--- a/bochs/cpu/softfloat3e/s_roundPackToF16.c
+++ b/bochs/cpu/softfloat3e/s_roundPackToF16.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float16_t
+float16
  softfloat_roundPackToF16(bool sign, int16_t exp, uint16_t sig, struct softfloat_status_t *status)
 {
     uint8_t roundingMode;
diff --git a/bochs/cpu/softfloat3e/s_roundPackToF32.c b/bochs/cpu/softfloat3e/s_roundPackToF32.c
index 197f47541..2a1de7497 100644
--- a/bochs/cpu/softfloat3e/s_roundPackToF32.c
+++ b/bochs/cpu/softfloat3e/s_roundPackToF32.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float32_t
+float32
  softfloat_roundPackToF32(bool sign, int16_t exp, uint32_t sig, struct softfloat_status_t *status)
 {
     uint8_t roundingMode;
diff --git a/bochs/cpu/softfloat3e/s_roundPackToF64.c b/bochs/cpu/softfloat3e/s_roundPackToF64.c
index 0903ddda2..65dccd181 100644
--- a/bochs/cpu/softfloat3e/s_roundPackToF64.c
+++ b/bochs/cpu/softfloat3e/s_roundPackToF64.c
@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float64_t
+float64
  softfloat_roundPackToF64(bool sign, int16_t exp, uint64_t sig, struct softfloat_status_t *status)
 {
     uint8_t roundingMode;
diff --git a/bochs/cpu/softfloat3e/s_subMagsF16.c b/bochs/cpu/softfloat3e/s_subMagsF16.c
index 451b33973..f725dda94 100644
--- a/bochs/cpu/softfloat3e/s_subMagsF16.c
+++ b/bochs/cpu/softfloat3e/s_subMagsF16.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float16_t softfloat_subMagsF16(uint16_t uiA, uint16_t uiB, struct softfloat_status_t *status)
+float16 softfloat_subMagsF16(uint16_t uiA, uint16_t uiB, struct softfloat_status_t *status)
 {
     int8_t expA;
     uint16_t sigA;
diff --git a/bochs/cpu/softfloat3e/s_subMagsF32.c b/bochs/cpu/softfloat3e/s_subMagsF32.c
index f32cb9723..95b41fa54 100644
--- a/bochs/cpu/softfloat3e/s_subMagsF32.c
+++ b/bochs/cpu/softfloat3e/s_subMagsF32.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float32_t softfloat_subMagsF32(uint32_t uiA, uint32_t uiB, struct softfloat_status_t *status)
+float32 softfloat_subMagsF32(uint32_t uiA, uint32_t uiB, struct softfloat_status_t *status)
 {
     int16_t expA;
     uint32_t sigA;
diff --git a/bochs/cpu/softfloat3e/s_subMagsF64.c b/bochs/cpu/softfloat3e/s_subMagsF64.c
index a5fd46a94..ea5663c63 100644
--- a/bochs/cpu/softfloat3e/s_subMagsF64.c
+++ b/bochs/cpu/softfloat3e/s_subMagsF64.c
@@ -40,7 +40,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "specialize.h"
 #include "softfloat.h"
 
-float64_t softfloat_subMagsF64(uint64_t uiA, uint64_t uiB, bool signZ, struct softfloat_status_t *status)
+float64 softfloat_subMagsF64(uint64_t uiA, uint64_t uiB, bool signZ, struct softfloat_status_t *status)
 {
     int16_t expA;
     uint64_t sigA;
diff --git a/bochs/cpu/softfloat3e/ui32_to_f16.c b/bochs/cpu/softfloat3e/ui32_to_f16.c
index da9ab324a..bda5b0b6f 100644
--- a/bochs/cpu/softfloat3e/ui32_to_f16.c
+++ b/bochs/cpu/softfloat3e/ui32_to_f16.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float16_t ui32_to_f16(uint32_t a, struct softfloat_status_t *status)
+float16 ui32_to_f16(uint32_t a, struct softfloat_status_t *status)
 {
     int8_t shiftDist;
     uint16_t sig;
diff --git a/bochs/cpu/softfloat3e/ui32_to_f32.c b/bochs/cpu/softfloat3e/ui32_to_f32.c
index b9e97c7b9..ee6d80346 100644
--- a/bochs/cpu/softfloat3e/ui32_to_f32.c
+++ b/bochs/cpu/softfloat3e/ui32_to_f32.c
@@ -37,7 +37,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "internals.h"
 #include "softfloat.h"
 
-float32_t ui32_to_f32(uint32_t a, struct softfloat_status_t *status)
+float32 ui32_to_f32(uint32_t a, struct softfloat_status_t *status)
 {
     if (! a) {
         return 0;
diff --git a/bochs/cpu/softfloat3e/ui32_to_f64.c b/bochs/cpu/softfloat3e/ui32_to_f64.c
index 90db0d20a..524d64eed 100644
--- a/bochs/cpu/softfloat3e/ui32_to_f64.c
+++ b/bochs/cpu/softfloat3e/ui32_to_f64.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float64_t ui32_to_f64(uint32_t a)
+float64 ui32_to_f64(uint32_t a)
 {
     if (! a) {
         return 0;
diff --git a/bochs/cpu/softfloat3e/ui64_to_f16.c b/bochs/cpu/softfloat3e/ui64_to_f16.c
index 9efded78c..f2339e905 100644
--- a/bochs/cpu/softfloat3e/ui64_to_f16.c
+++ b/bochs/cpu/softfloat3e/ui64_to_f16.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float16_t ui64_to_f16(uint64_t a, struct softfloat_status_t *status)
+float16 ui64_to_f16(uint64_t a, struct softfloat_status_t *status)
 {
     int8_t shiftDist;
     uint16_t sig;
diff --git a/bochs/cpu/softfloat3e/ui64_to_f32.c b/bochs/cpu/softfloat3e/ui64_to_f32.c
index cefd69d2e..62db84783 100644
--- a/bochs/cpu/softfloat3e/ui64_to_f32.c
+++ b/bochs/cpu/softfloat3e/ui64_to_f32.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float32_t ui64_to_f32(uint64_t a, struct softfloat_status_t *status)
+float32 ui64_to_f32(uint64_t a, struct softfloat_status_t *status)
 {
     int8_t shiftDist;
     uint32_t sig;
diff --git a/bochs/cpu/softfloat3e/ui64_to_f64.c b/bochs/cpu/softfloat3e/ui64_to_f64.c
index 89163190c..05f849a1a 100644
--- a/bochs/cpu/softfloat3e/ui64_to_f64.c
+++ b/bochs/cpu/softfloat3e/ui64_to_f64.c
@@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "primitives.h"
 #include "softfloat.h"
 
-float64_t ui64_to_f64(uint64_t a, struct softfloat_status_t *status)
+float64 ui64_to_f64(uint64_t a, struct softfloat_status_t *status)
 {
     if (! a) {
         return 0;