put in typedef sv_floatNN_t

diff --git a/riscv/sv_insn_redirect.cc b/riscv/sv_insn_redirect.cc
index 24e03c05884033b0e8d5c8404abfaf63501a041d..c5029d0a77925a1c4b085db5dab770dbc115358c 100644 (file)
--- a/riscv/sv_insn_redirect.cc
+++ b/riscv/sv_insn_redirect.cc
@@ -3,15 +3,15 @@
 #include "mulhi.h"
 #include "sv_reg.h"
 
-void (sv_proc_t::WRITE_FRD)(float32_t value)
+void (sv_proc_t::WRITE_FRD)(sv_float32_t value)
 {
-    fprintf(stderr, "WRITE_FRD float32_t %f\n", (float)value.v);
+    fprintf(stderr, "WRITE_FRD sv_float32_t %f\n", (float)value.v);
     DO_WRITE_FREG( _insn->rd(), freg(value) );
 }
 
-void (sv_proc_t::WRITE_FRD)(float64_t value)
+void (sv_proc_t::WRITE_FRD)(sv_float64_t value)
 {
-    fprintf(stderr, "WRITE_FRD float64_t %g\n", (double)value.v);
+    fprintf(stderr, "WRITE_FRD sv_float64_t %g\n", (double)value.v);
     DO_WRITE_FREG( _insn->rd(), freg(value) );
 }
 
@@ -21,12 +21,12 @@ void (sv_proc_t::WRITE_FRD)(freg_t value)
     DO_WRITE_FREG( _insn->rd(), freg(value) );
 }
 
-void (sv_proc_t::WRITE_RVC_FRS2S)(float32_t value)
+void (sv_proc_t::WRITE_RVC_FRS2S)(sv_float32_t value)
 {
     WRITE_FREG(_insn->rvc_rs2s(), freg(value));
 }
 
-void (sv_proc_t::WRITE_RVC_FRS2S)(float64_t const& value)
+void (sv_proc_t::WRITE_RVC_FRS2S)(sv_float64_t const& value)
 {
     WRITE_FREG(_insn->rvc_rs2s(), freg(value));
 }
@@ -502,181 +502,181 @@ sv_reg_t sv_proc_t::sv_reg_uint32(sv_reg_t const& v)
     return sv_reg_t((uint64_t)x);
 }
 
-float32_t (sv_proc_t::f32)(freg_t x)
+sv_float32_t (sv_proc_t::f32)(freg_t x)
 {
     return ::f32(x);
 }
-float32_t (sv_proc_t::f32)(sv_reg_t const& v)
+sv_float32_t (sv_proc_t::f32)(sv_reg_t const& v)
 {
     uint64_t x = v;
     return ::f32(x);
 }
 
-float64_t (sv_proc_t::f64)(freg_t v)
+sv_float64_t (sv_proc_t::f64)(freg_t v)
 {
     return ::f64(v);
 }
 
-float64_t (sv_proc_t::f64)(sv_reg_t const& v)
+sv_float64_t (sv_proc_t::f64)(sv_reg_t const& v)
 {
     uint64_t x = v;
     return ::f64(x);
 }
 
-sv_reg_t (sv_proc_t::f32_classify)(float32_t a)
+sv_reg_t (sv_proc_t::f32_classify)(sv_float32_t a)
 {
     return sv_reg_t(::f32_classify(a));
 }
 
-sv_reg_t (sv_proc_t::f64_classify)(float64_t a)
+sv_reg_t (sv_proc_t::f64_classify)(sv_float64_t a)
 {
     return sv_reg_t(::f64_classify(a));
 }
 
-sv_reg_t (sv_proc_t::f128_classify)(float128_t a)
+sv_reg_t (sv_proc_t::f128_classify)(sv_float128_t a)
 {
     return sv_reg_t(::f128_classify(a));
 }
 
-float32_t (sv_proc_t::i32_to_f32)( sv_reg_t const& v )
+sv_float32_t (sv_proc_t::i32_to_f32)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::i32_to_f32(x);
 }
 
-float64_t (sv_proc_t::ui32_to_f64)( sv_reg_t const& v )
+sv_float64_t (sv_proc_t::ui32_to_f64)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::ui32_to_f64(x);
 }
 
-float64_t (sv_proc_t::i32_to_f64)( sv_reg_t const& v )
+sv_float64_t (sv_proc_t::i32_to_f64)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::i32_to_f64(x);
 }
 
-float32_t (sv_proc_t::ui32_to_f32)( sv_reg_t const& v )
+sv_float32_t (sv_proc_t::ui32_to_f32)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::ui32_to_f32(x);
 }
 
-float32_t (sv_proc_t::i64_to_f32)( sv_reg_t const& v )
+sv_float32_t (sv_proc_t::i64_to_f32)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::i64_to_f32(x);
 }
 
-float32_t (sv_proc_t::ui64_to_f32)( sv_reg_t const& v )
+sv_float32_t (sv_proc_t::ui64_to_f32)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::ui64_to_f32(x);
 }
 
-float64_t (sv_proc_t::i64_to_f64)( sv_reg_t const& v )
+sv_float64_t (sv_proc_t::i64_to_f64)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::i64_to_f64(x);
 }
 
-float64_t (sv_proc_t::ui64_to_f64)( sv_reg_t const& v )
+sv_float64_t (sv_proc_t::ui64_to_f64)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::ui64_to_f64(x);
 }
 
-float128_t (sv_proc_t::ui64_to_f128)( sv_reg_t const& v )
+sv_float128_t (sv_proc_t::ui64_to_f128)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::ui64_to_f128(x);
 }
 
-float128_t (sv_proc_t::i64_to_f128)( sv_reg_t const& v )
+sv_float128_t (sv_proc_t::i64_to_f128)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::i64_to_f128(x);
 }
 
-float128_t (sv_proc_t::i32_to_f128)( sv_reg_t const& v )
+sv_float128_t (sv_proc_t::i32_to_f128)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::i32_to_f128(x);
 }
 
-float128_t (sv_proc_t::ui32_to_f128)( sv_reg_t const& v )
+sv_float128_t (sv_proc_t::ui32_to_f128)( sv_reg_t const& v )
 {
     uint64_t x = v;
     return ::ui32_to_f128(x);
 }
 
-sv_reg_t (sv_proc_t::f32_to_ui32)( float32_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f32_to_ui32)( sv_float32_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f32_to_ui32(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f32_to_i32)( float32_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f32_to_i32)( sv_float32_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f32_to_i32(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f32_to_i64)( float32_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f32_to_i64)( sv_float32_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f32_to_i64(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f32_to_ui64)( float32_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f32_to_ui64)( sv_float32_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f32_to_ui64(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f64_to_ui32)( float64_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f64_to_ui32)( sv_float64_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f64_to_ui32(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f64_to_i32)( float64_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f64_to_i32)( sv_float64_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f64_to_i32(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f64_to_i64)( float64_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f64_to_i64)( sv_float64_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f64_to_i64(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f64_to_ui64)( float64_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f64_to_ui64)( sv_float64_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f64_to_ui64(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f128_to_ui64)( float128_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f128_to_ui64)( sv_float128_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f128_to_ui64(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f128_to_ui32)( float128_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f128_to_ui32)( sv_float128_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f128_to_ui32(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f128_to_i32)( float128_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f128_to_i32)( sv_float128_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f128_to_i32(a, roundingMode, exact));
 }
 
-sv_reg_t (sv_proc_t::f128_to_i64)( float128_t a, uint_fast8_t roundingMode,
+sv_reg_t (sv_proc_t::f128_to_i64)( sv_float128_t a, uint_fast8_t roundingMode,
                                  bool exact )
 {
     return sv_reg_t(::f128_to_i64(a, roundingMode, exact));
@@ -699,67 +699,67 @@ sv_reg_t (sv_proc_t::mulhu)(sv_reg_t const& a, sv_reg_t const& b)
 
 // --------
 
-float64_t (sv_proc_t::f64_add)( float64_t a, float64_t b )
+sv_float64_t (sv_proc_t::f64_add)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_add(a, b);
 }
 
-float64_t (sv_proc_t::f64_sub)( float64_t a, float64_t b )
+sv_float64_t (sv_proc_t::f64_sub)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_sub(a, b);
 }
 
-float64_t (sv_proc_t::f64_mul)( float64_t a, float64_t b )
+sv_float64_t (sv_proc_t::f64_mul)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_mul(a, b);
 }
 
-float64_t (sv_proc_t::f64_mulAdd)( float64_t a, float64_t b , float64_t c)
+sv_float64_t (sv_proc_t::f64_mulAdd)( sv_float64_t a, sv_float64_t b , sv_float64_t c)
 {
     return ::f64_mulAdd(a, b, c);
 }
 
-float64_t (sv_proc_t::f64_div)( float64_t a, float64_t b )
+sv_float64_t (sv_proc_t::f64_div)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_div(a, b);
 }
 
-float64_t (sv_proc_t::f64_rem)( float64_t a, float64_t b )
+sv_float64_t (sv_proc_t::f64_rem)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_rem(a, b);
 }
 
-float64_t (sv_proc_t::f64_sqrt)( float64_t a )
+sv_float64_t (sv_proc_t::f64_sqrt)( sv_float64_t a )
 {
     return ::f64_sqrt(a);
 }
 
-bool (sv_proc_t::f64_eq)( float64_t a, float64_t b )
+bool (sv_proc_t::f64_eq)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_eq(a, b);
 }
 
-bool (sv_proc_t::f64_le)( float64_t a, float64_t b )
+bool (sv_proc_t::f64_le)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_le(a, b);
 }
 
-bool (sv_proc_t::f64_lt)( float64_t a, float64_t b )
+bool (sv_proc_t::f64_lt)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_lt(a, b);
 }
 
-bool (sv_proc_t::f64_eq_signaling)( float64_t a, float64_t b )
+bool (sv_proc_t::f64_eq_signaling)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_eq_signaling(a, b);
 }
 
-bool (sv_proc_t::f64_le_quiet)( float64_t a, float64_t b )
+bool (sv_proc_t::f64_le_quiet)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_le_quiet(a, b);
 }
 
-bool (sv_proc_t::f64_lt_quiet)( float64_t a, float64_t b )
+bool (sv_proc_t::f64_lt_quiet)( sv_float64_t a, sv_float64_t b )
 {
     return ::f64_lt_quiet(a, b);
 }
@@ -767,67 +767,67 @@ bool (sv_proc_t::f64_lt_quiet)( float64_t a, float64_t b )
 
 // --------
 
-float32_t (sv_proc_t::f32_add)( float32_t a, float32_t b )
+sv_float32_t (sv_proc_t::f32_add)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_add(a, b);
 }
 
-float32_t (sv_proc_t::f32_sub)( float32_t a, float32_t b )
+sv_float32_t (sv_proc_t::f32_sub)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_sub(a, b);
 }
 
-float32_t (sv_proc_t::f32_mul)( float32_t a, float32_t b )
+sv_float32_t (sv_proc_t::f32_mul)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_mul(a, b);
 }
 
-float32_t (sv_proc_t::f32_mulAdd)( float32_t a, float32_t b , float32_t c)
+sv_float32_t (sv_proc_t::f32_mulAdd)( sv_float32_t a, sv_float32_t b , sv_float32_t c)
 {
     return ::f32_mulAdd(a, b, c);
 }
 
-float32_t (sv_proc_t::f32_div)( float32_t a, float32_t b )
+sv_float32_t (sv_proc_t::f32_div)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_div(a, b);
 }
 
-float32_t (sv_proc_t::f32_rem)( float32_t a, float32_t b )
+sv_float32_t (sv_proc_t::f32_rem)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_rem(a, b);
 }
 
-float32_t (sv_proc_t::f32_sqrt)( float32_t a )
+sv_float32_t (sv_proc_t::f32_sqrt)( sv_float32_t a )
 {
     return ::f32_sqrt(a);
 }
 
-bool (sv_proc_t::f32_eq)( float32_t a, float32_t b )
+bool (sv_proc_t::f32_eq)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_eq(a, b);
 }
 
-bool (sv_proc_t::f32_le)( float32_t a, float32_t b )
+bool (sv_proc_t::f32_le)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_le(a, b);
 }
 
-bool (sv_proc_t::f32_lt)( float32_t a, float32_t b )
+bool (sv_proc_t::f32_lt)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_lt(a, b);
 }
 
-bool (sv_proc_t::f32_eq_signaling)( float32_t a, float32_t b )
+bool (sv_proc_t::f32_eq_signaling)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_eq_signaling(a, b);
 }
 
-bool (sv_proc_t::f32_le_quiet)( float32_t a, float32_t b )
+bool (sv_proc_t::f32_le_quiet)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_le_quiet(a, b);
 }
 
-bool (sv_proc_t::f32_lt_quiet)( float32_t a, float32_t b )
+bool (sv_proc_t::f32_lt_quiet)( sv_float32_t a, sv_float32_t b )
 {
     return ::f32_lt_quiet(a, b);
 }
@@ -835,67 +835,67 @@ bool (sv_proc_t::f32_lt_quiet)( float32_t a, float32_t b )
 
 // --------
 
-float128_t (sv_proc_t::f128_add)( float128_t a, float128_t b )
+sv_float128_t (sv_proc_t::f128_add)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_add(a, b);
 }
 
-float128_t (sv_proc_t::f128_sub)( float128_t a, float128_t b )
+sv_float128_t (sv_proc_t::f128_sub)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_sub(a, b);
 }
 
-float128_t (sv_proc_t::f128_mul)( float128_t a, float128_t b )
+sv_float128_t (sv_proc_t::f128_mul)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_mul(a, b);
 }
 
-float128_t (sv_proc_t::f128_mulAdd)( float128_t a, float128_t b , float128_t c)
+sv_float128_t (sv_proc_t::f128_mulAdd)( sv_float128_t a, sv_float128_t b , sv_float128_t c)
 {
     return ::f128_mulAdd(a, b, c);
 }
 
-float128_t (sv_proc_t::f128_div)( float128_t a, float128_t b )
+sv_float128_t (sv_proc_t::f128_div)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_div(a, b);
 }
 
-float128_t (sv_proc_t::f128_rem)( float128_t a, float128_t b )
+sv_float128_t (sv_proc_t::f128_rem)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_rem(a, b);
 }
 
-float128_t (sv_proc_t::f128_sqrt)( float128_t a )
+sv_float128_t (sv_proc_t::f128_sqrt)( sv_float128_t a )
 {
     return ::f128_sqrt(a);
 }
 
-bool (sv_proc_t::f128_eq)( float128_t a, float128_t b )
+bool (sv_proc_t::f128_eq)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_eq(a, b);
 }
 
-bool (sv_proc_t::f128_le)( float128_t a, float128_t b )
+bool (sv_proc_t::f128_le)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_le(a, b);
 }
 
-bool (sv_proc_t::f128_lt)( float128_t a, float128_t b )
+bool (sv_proc_t::f128_lt)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_lt(a, b);
 }
 
-bool (sv_proc_t::f128_eq_signaling)( float128_t a, float128_t b )
+bool (sv_proc_t::f128_eq_signaling)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_eq_signaling(a, b);
 }
 
-bool (sv_proc_t::f128_le_quiet)( float128_t a, float128_t b )
+bool (sv_proc_t::f128_le_quiet)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_le_quiet(a, b);
 }
 
-bool (sv_proc_t::f128_lt_quiet)( float128_t a, float128_t b )
+bool (sv_proc_t::f128_lt_quiet)( sv_float128_t a, sv_float128_t b )
 {
     return ::f128_lt_quiet(a, b);
 }

diff --git a/riscv/sv_insn_redirect.h b/riscv/sv_insn_redirect.h
index db219182fdb0befab2f9452882b59b2858306375..d5ee76f11ec2d48e09276269e91f90c5206dc892 100644 (file)
--- a/riscv/sv_insn_redirect.h
+++ b/riscv/sv_insn_redirect.h
@@ -56,6 +56,9 @@ class insn_t;
 
 //typedef reg_t sv_reg_t;
 //typedef sreg_t sv_sreg_t;
+typedef float32_t sv_float32_t;
+typedef float64_t sv_float64_t;
+typedef float128_t sv_float128_t;
 
 class sv_proc_t
 {
@@ -68,8 +71,8 @@ public:
     void (WRITE_RD)(sv_reg_t const& value); // XXX TODO investigate
     //void (WRITE_RD)(sv_sreg_t value); // XXX TODO investigate
     void (WRITE_RVC_RS2S)(sv_reg_t const& value); // XXX TODO investigate
-    void (WRITE_RVC_FRS2S)(float64_t const& value); // XXX TODO investigate
-    void (WRITE_RVC_FRS2S)(float32_t value); // XXX TODO investigate
+    void (WRITE_RVC_FRS2S)(sv_float64_t const& value); // XXX TODO investigate
+    void (WRITE_RVC_FRS2S)(sv_float32_t value); // XXX TODO investigate
     //void (WRITE_RVC_RS2S)(sv_sreg_t value); // XXX TODO investigate
     void (WRITE_RVC_RS1S)(sv_reg_t const& value); // XXX TODO investigate
     //void (WRITE_RVC_RS1S)(sv_sreg_t value); // XXX TODO investigate
@@ -78,8 +81,8 @@ public:
     void (WRITE_REG)(reg_spec_t const&reg, sv_reg_t const& value);
     //void (WRITE_REG)(reg_t reg, sv_sreg_t value);
     void (WRITE_FRD)(freg_t value);
-    void (WRITE_FRD)(float64_t value);
-    void (WRITE_FRD)(float32_t value);
+    void (WRITE_FRD)(sv_float64_t value);
+    void (WRITE_FRD)(sv_float32_t value);
     reg_t (READ_REG)(reg_spec_t const& i);
     freg_t (READ_FREG)(reg_spec_t const& i);
 
@@ -163,48 +166,48 @@ public:
     sv_reg_t sv_reg_uint32(sv_reg_t const&);
     sv_reg_t sv_reg_int32(sv_reg_t const&);
 
-    float64_t (f64)(freg_t  v);
-    float64_t (f64)(sv_reg_t  const&v);
-    float32_t (f32)(sv_reg_t  const&v);
-    float32_t (f32)(freg_t v);
-    sv_reg_t (f32_classify)(float32_t  a);
-    sv_reg_t (f64_classify)(float64_t  a);
-    sv_reg_t (f128_classify)(float128_t  a);
-    float32_t (i32_to_f32)(sv_reg_t  const&a);
-    float32_t (i64_to_f32)(sv_reg_t  const&a);
-    float32_t (ui64_to_f32)(sv_reg_t  const&a);
-    float32_t (ui32_to_f32)(sv_reg_t  const&a);
-    float64_t (i64_to_f64)(sv_reg_t  const&a);
-    float64_t (ui64_to_f64)(sv_reg_t  const&a);
-    float64_t (ui32_to_f64)(sv_reg_t  const&a);
-    float64_t (i32_to_f64)(sv_reg_t  const&a);
-    float128_t (i32_to_f128)(sv_reg_t  const&a);
-    float128_t (ui32_to_f128)(sv_reg_t  const&a);
-    float128_t (i64_to_f128)(sv_reg_t  const&a);
-    float128_t (ui64_to_f128)(sv_reg_t  const&a);
-    sv_reg_t (f32_to_ui32)( float32_t a, uint_fast8_t roundingMode,
+    sv_float64_t (f64)(freg_t  v);
+    sv_float64_t (f64)(sv_reg_t  const&v);
+    sv_float32_t (f32)(sv_reg_t  const&v);
+    sv_float32_t (f32)(freg_t v);
+    sv_reg_t (f32_classify)(sv_float32_t  a);
+    sv_reg_t (f64_classify)(sv_float64_t  a);
+    sv_reg_t (f128_classify)(sv_float128_t  a);
+    sv_float32_t (i32_to_f32)(sv_reg_t  const&a);
+    sv_float32_t (i64_to_f32)(sv_reg_t  const&a);
+    sv_float32_t (ui64_to_f32)(sv_reg_t  const&a);
+    sv_float32_t (ui32_to_f32)(sv_reg_t  const&a);
+    sv_float64_t (i64_to_f64)(sv_reg_t  const&a);
+    sv_float64_t (ui64_to_f64)(sv_reg_t  const&a);
+    sv_float64_t (ui32_to_f64)(sv_reg_t  const&a);
+    sv_float64_t (i32_to_f64)(sv_reg_t  const&a);
+    sv_float128_t (i32_to_f128)(sv_reg_t  const&a);
+    sv_float128_t (ui32_to_f128)(sv_reg_t  const&a);
+    sv_float128_t (i64_to_f128)(sv_reg_t  const&a);
+    sv_float128_t (ui64_to_f128)(sv_reg_t  const&a);
+    sv_reg_t (f32_to_ui32)( sv_float32_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f32_to_i32)( float32_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f32_to_i32)( sv_float32_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f32_to_i64)( float32_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f32_to_i64)( sv_float32_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f32_to_ui64)( float32_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f32_to_ui64)( sv_float32_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f64_to_ui64)( float64_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f64_to_ui64)( sv_float64_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f64_to_i32)( float64_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f64_to_i32)( sv_float64_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f64_to_ui32)( float64_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f64_to_ui32)( sv_float64_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f64_to_i64)( float64_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f64_to_i64)( sv_float64_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f128_to_ui32)( float128_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f128_to_ui32)( sv_float128_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f128_to_i32)( float128_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f128_to_i32)( sv_float128_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f128_to_i64)( float128_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f128_to_i64)( sv_float128_t a, uint_fast8_t roundingMode,
                                  bool exact );
-    sv_reg_t (f128_to_ui64)( float128_t a, uint_fast8_t roundingMode,
+    sv_reg_t (f128_to_ui64)( sv_float128_t a, uint_fast8_t roundingMode,
                                  bool exact );
 
 
@@ -212,48 +215,48 @@ public:
     sv_reg_t (mulhu)(sv_reg_t const& a, sv_reg_t const& b);
     sv_sreg_t (mulh)(sv_sreg_t const& a, sv_sreg_t const& b);
 
-    float64_t f64_add( float64_t, float64_t );
-    float64_t f64_sub( float64_t, float64_t );
-    float64_t f64_mul( float64_t, float64_t );
-    float64_t f64_mulAdd( float64_t, float64_t, float64_t );
-    float64_t f64_div( float64_t, float64_t );
-    float64_t f64_rem( float64_t, float64_t );
-    float64_t f64_sqrt( float64_t );
-    bool f64_eq( float64_t, float64_t );
-    bool f64_le( float64_t, float64_t );
-    bool f64_lt( float64_t, float64_t );
-    bool f64_eq_signaling( float64_t, float64_t );
-    bool f64_le_quiet( float64_t, float64_t );
-    bool f64_lt_quiet( float64_t, float64_t );
+    sv_float64_t f64_add( sv_float64_t, sv_float64_t );
+    sv_float64_t f64_sub( sv_float64_t, sv_float64_t );
+    sv_float64_t f64_mul( sv_float64_t, sv_float64_t );
+    sv_float64_t f64_mulAdd( sv_float64_t, sv_float64_t, sv_float64_t );
+    sv_float64_t f64_div( sv_float64_t, sv_float64_t );
+    sv_float64_t f64_rem( sv_float64_t, sv_float64_t );
+    sv_float64_t f64_sqrt( sv_float64_t );
+    bool f64_eq( sv_float64_t, sv_float64_t );
+    bool f64_le( sv_float64_t, sv_float64_t );
+    bool f64_lt( sv_float64_t, sv_float64_t );
+    bool f64_eq_signaling( sv_float64_t, sv_float64_t );
+    bool f64_le_quiet( sv_float64_t, sv_float64_t );
+    bool f64_lt_quiet( sv_float64_t, sv_float64_t );
 
-    float32_t f32_add( float32_t, float32_t );
-    float32_t f32_sub( float32_t, float32_t );
-    float32_t f32_mul( float32_t, float32_t );
-    float32_t f32_mulAdd( float32_t, float32_t, float32_t );
-    float32_t f32_div( float32_t, float32_t );
-    float32_t f32_rem( float32_t, float32_t );
-    float32_t f32_sqrt( float32_t );
-    bool f32_eq( float32_t, float32_t );
-    bool f32_le( float32_t, float32_t );
-    bool f32_lt( float32_t, float32_t );
-    bool f32_eq_signaling( float32_t, float32_t );
-    bool f32_le_quiet( float32_t, float32_t );
-    bool f32_lt_quiet( float32_t, float32_t );
+    sv_float32_t f32_add( sv_float32_t, sv_float32_t );
+    sv_float32_t f32_sub( sv_float32_t, sv_float32_t );
+    sv_float32_t f32_mul( sv_float32_t, sv_float32_t );
+    sv_float32_t f32_mulAdd( sv_float32_t, sv_float32_t, sv_float32_t );
+    sv_float32_t f32_div( sv_float32_t, sv_float32_t );
+    sv_float32_t f32_rem( sv_float32_t, sv_float32_t );
+    sv_float32_t f32_sqrt( sv_float32_t );
+    bool f32_eq( sv_float32_t, sv_float32_t );
+    bool f32_le( sv_float32_t, sv_float32_t );
+    bool f32_lt( sv_float32_t, sv_float32_t );
+    bool f32_eq_signaling( sv_float32_t, sv_float32_t );
+    bool f32_le_quiet( sv_float32_t, sv_float32_t );
+    bool f32_lt_quiet( sv_float32_t, sv_float32_t );
 
 
-    float128_t f128_add( float128_t, float128_t );
-    float128_t f128_sub( float128_t, float128_t );
-    float128_t f128_mul( float128_t, float128_t );
-    float128_t f128_mulAdd( float128_t, float128_t, float128_t );
-    float128_t f128_div( float128_t, float128_t );
-    float128_t f128_rem( float128_t, float128_t );
-    float128_t f128_sqrt( float128_t );
-    bool f128_eq( float128_t, float128_t );
-    bool f128_le( float128_t, float128_t );
-    bool f128_lt( float128_t, float128_t );
-    bool f128_eq_signaling( float128_t, float128_t );
-    bool f128_le_quiet( float128_t, float128_t );
-    bool f128_lt_quiet( float128_t, float128_t );
+    sv_float128_t f128_add( sv_float128_t, sv_float128_t );
+    sv_float128_t f128_sub( sv_float128_t, sv_float128_t );
+    sv_float128_t f128_mul( sv_float128_t, sv_float128_t );
+    sv_float128_t f128_mulAdd( sv_float128_t, sv_float128_t, sv_float128_t );
+    sv_float128_t f128_div( sv_float128_t, sv_float128_t );
+    sv_float128_t f128_rem( sv_float128_t, sv_float128_t );
+    sv_float128_t f128_sqrt( sv_float128_t );
+    bool f128_eq( sv_float128_t, sv_float128_t );
+    bool f128_le( sv_float128_t, sv_float128_t );
+    bool f128_lt( sv_float128_t, sv_float128_t );
+    bool f128_eq_signaling( sv_float128_t, sv_float128_t );
+    bool f128_le_quiet( sv_float128_t, sv_float128_t );
+    bool f128_lt_quiet( sv_float128_t, sv_float128_t );
 
 
 #include "sv_insn_decl.h"