Merge from SVN #531

[CL] add 'f' suffix to 'float' constants

24 files changed, 75 insertions, 75 deletions

diff --git a/ref_v_comp_f_op.c b/ref_v_comp_f_op.c
index 9ec7e32..57ac325 100644
--- a/ref_v_comp_f_op.c
+++ b/ref_v_comp_f_op.c
@@ -65,8 +65,8 @@ FNNAME (INSN_NAME)
 
   /* Choose init value arbitrarily, will be used for vector
      comparison */
-  TEST_VDUP(vector2, , float, f, 32, 2, -16.0);
-  TEST_VDUP(vector2, q, float, f, 32, 4, -14.0);
+  TEST_VDUP(vector2, , float, f, 32, 2, -16.0f);
+  TEST_VDUP(vector2, q, float, f, 32, 4, -14.0f);
 
   fprintf(ref_file, "\n%s output:\n", TEST_MSG);
   TEST_VCOMP(INSN_NAME, , float, f, uint, 32, 2);
@@ -75,8 +75,8 @@ FNNAME (INSN_NAME)
   TEST_VCOMP(INSN_NAME, q, float, f, uint, 32, 4);
   DUMP(TEST_MSG, uint, 32, 4, PRIx32);
 
-  TEST_VDUP(vector2, , float, f, 32, 2, -10.0);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 10.0);
+  TEST_VDUP(vector2, , float, f, 32, 2, -10.0f);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 10.0f);
 
   fprintf(ref_file, "\n%s output:\n", TEST_MSG);
   TEST_VCOMP(INSN_NAME, , float, f, uint, 32, 2);
diff --git a/ref_v_comp_op.c b/ref_v_comp_op.c
index 6def17d..c36f461 100644
--- a/ref_v_comp_op.c
+++ b/ref_v_comp_op.c
@@ -116,7 +116,7 @@ FNNAME (INSN_NAME)
   TEST_VDUP(vector2, , uint, u, 8, 8, 0xF3);
   TEST_VDUP(vector2, , uint, u, 16, 4, 0xFFF2);
   TEST_VDUP(vector2, , uint, u, 32, 2, 0xFFFFFFF1);
-  TEST_VDUP(vector2, , float, f, 32, 2, -15.0);
+  TEST_VDUP(vector2, , float, f, 32, 2, -15.0f);
 
   TEST_VDUP(vector2, q, int, s, 8, 16, -4);
   TEST_VDUP(vector2, q, int, s, 16, 8, -10);
@@ -124,7 +124,7 @@ FNNAME (INSN_NAME)
   TEST_VDUP(vector2, q, uint, u, 8, 16, 0xF4);
   TEST_VDUP(vector2, q, uint, u, 16, 8, 0xFFF6);
   TEST_VDUP(vector2, q, uint, u, 32, 4, 0xFFFFFFF2);
-  TEST_VDUP(vector2, q, float, f, 32, 4, -14.0);
+  TEST_VDUP(vector2, q, float, f, 32, 4, -14.0f);
 
   /* The same result buffers are used multiple times, so output them
      before overwriting them  */
@@ -172,7 +172,7 @@ FNNAME (INSN_NAME)
   TEST_VCOMP(INSN_NAME, , int, s, uint, 32, 2);
   DUMP(TEST_MSG, uint, 32, 2, PRIx32);
 
-  TEST_VDUP(vector2, , float, f, 32, 2, -16.0);
+  TEST_VDUP(vector2, , float, f, 32, 2, -16.0f);
   TEST_VCOMP(INSN_NAME, , float, f, uint, 32, 2);
   DUMP(TEST_MSG, uint, 32, 2, PRIx32);
 }
diff --git a/ref_vabd.c b/ref_vabd.c
index 5b1420c..b639b27 100644
--- a/ref_vabd.c
+++ b/ref_vabd.c
@@ -88,14 +88,14 @@ void exec_vabd (void)
   TEST_VDUP(vector2, , uint, u, 8, 8, 1);
   TEST_VDUP(vector2, , uint, u, 16, 4, 13);
   TEST_VDUP(vector2, , uint, u, 32, 2, 8);
-  TEST_VDUP(vector2, , float, f, 32, 2, 8.3);
+  TEST_VDUP(vector2, , float, f, 32, 2, 8.3f);
   TEST_VDUP(vector2, q, int, s, 8, 16, 10);
   TEST_VDUP(vector2, q, int, s, 16, 8, -12);
   TEST_VDUP(vector2, q, int, s, 32, 4, 32);
   TEST_VDUP(vector2, q, uint, u, 8, 16, 10);
   TEST_VDUP(vector2, q, uint, u, 16, 8, 12);
   TEST_VDUP(vector2, q, uint, u, 32, 4, 32);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 32.12);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 32.12f);
 
   TEST_VABD(, int, s, 8, 8);
   TEST_VABD(, int, s, 16, 4);
diff --git a/ref_vabs.c b/ref_vabs.c
index d8f1e2d..174e814 100644
--- a/ref_vabs.c
+++ b/ref_vabs.c
@@ -42,8 +42,8 @@ void exec_vabs_f32(void)
   DECL_VARIABLE(vector_res, float, 32, 2);
   DECL_VARIABLE(vector_res, float, 32, 4);
 
-  TEST_VDUP(vector, , float, f, 32, 2, -2.3);
-  TEST_VDUP(vector, q, float, f, 32, 4, 3.4);
+  TEST_VDUP(vector, , float, f, 32, 2, -2.3f);
+  TEST_VDUP(vector, q, float, f, 32, 4, 3.4f);
 
   TEST_UNARY_OP(INSN_NAME, , float, f, 32, 2);
   TEST_UNARY_OP(INSN_NAME, q, float, f, 32, 4);
diff --git a/ref_vadd.c b/ref_vadd.c
index 29d96c6..b08347b 100644
--- a/ref_vadd.c
+++ b/ref_vadd.c
@@ -45,11 +45,11 @@ void exec_vadd_f32(void)
   DECL_VARIABLE(vector_res, float, 32, 2);
   DECL_VARIABLE(vector_res, float, 32, 4);
 
-  TEST_VDUP(vector, , float, f, 32, 2, 2.3);
-  TEST_VDUP(vector, q, float, f, 32, 4, 3.4);
+  TEST_VDUP(vector, , float, f, 32, 2, 2.3f);
+  TEST_VDUP(vector, q, float, f, 32, 4, 3.4f);
 
-  TEST_VDUP(vector2, , float, f, 32, 2, 4.5);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 5.6);
+  TEST_VDUP(vector2, , float, f, 32, 2, 4.5f);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 5.6f);
 
   TEST_BINARY_OP(INSN_NAME, , float, f, 32, 2);
   TEST_BINARY_OP(INSN_NAME, q, float, f, 32, 4);
diff --git a/ref_vbsl.c b/ref_vbsl.c
index 3bd8933..81c502b 100644
--- a/ref_vbsl.c
+++ b/ref_vbsl.c
@@ -67,7 +67,7 @@ void exec_vbsl (void)
   TEST_VDUP(vector2, , uint, u, 16, 4, 0xFFF2);
   TEST_VDUP(vector2, , uint, u, 32, 2, 0xFFFFFFF0);
   TEST_VDUP(vector2, , uint, u, 64, 1, 0xFFFFFFF3);
-  TEST_VDUP(vector2, , float, f, 32, 2, -30.3);
+  TEST_VDUP(vector2, , float, f, 32, 2, -30.3f);
 
   TEST_VDUP(vector2, q, int, s, 8, 16, -10);
   TEST_VDUP(vector2, q, int, s, 16, 8, -14);
@@ -77,7 +77,7 @@ void exec_vbsl (void)
   TEST_VDUP(vector2, q, uint, u, 16, 8, 0xFFF2);
   TEST_VDUP(vector2, q, uint, u, 32, 4, 0xFFFFFFF0);
   TEST_VDUP(vector2, q, uint, u, 64, 2, 0xFFFFFFF3);
-  TEST_VDUP(vector2, q, float, f, 32, 4, -30.4);
+  TEST_VDUP(vector2, q, float, f, 32, 4, -30.4f);
 
   TEST_VDUP(vector_first, , uint, u, 8, 8, 0xF4);
   TEST_VDUP(vector_first, , uint, u, 16, 4, 0xFFF6);
diff --git a/ref_vcombine.c b/ref_vcombine.c
index 0aa3cbf..b43e4dd 100644
--- a/ref_vcombine.c
+++ b/ref_vcombine.c
@@ -59,7 +59,7 @@ void exec_vcombine (void)
   TEST_VDUP(vector64_b, , uint, u, 16, 4, 0x66);
   TEST_VDUP(vector64_b, , uint, u, 32, 2, 0x77);
   TEST_VDUP(vector64_b, , uint, u, 64, 1, 0x88);
-  TEST_VDUP(vector64_b, , float, f, 32, 2, 3.3);
+  TEST_VDUP(vector64_b, , float, f, 32, 2, 3.3f);
 
   clean_results ();
 
diff --git a/ref_vcvt.c b/ref_vcvt.c
index 45553d0..806db3c 100644
--- a/ref_vcvt.c
+++ b/ref_vcvt.c
@@ -80,10 +80,10 @@ void exec_vcvt (void)
 
   /* Make sure some elements have a fractional part, to exercise
      integer conversions */
-  TEST_VSET_LANE(vector, , float, f, 32, 2, 0, -15.3);
-  TEST_VSET_LANE(vector, , float, f, 32, 2, 1, 5.3);
-  TEST_VSET_LANE(vector, q, float, f, 32, 4, 2, -15.3);
-  TEST_VSET_LANE(vector, q, float, f, 32, 4, 3, 5.3);
+  TEST_VSET_LANE(vector, , float, f, 32, 2, 0, -15.3f);
+  TEST_VSET_LANE(vector, , float, f, 32, 2, 1, 5.3f);
+  TEST_VSET_LANE(vector, q, float, f, 32, 4, 2, -15.3f);
+  TEST_VSET_LANE(vector, q, float, f, 32, 4, 3, 5.3f);
 
   /* The same result buffers are used multiple times, so we output
      them before overwriting them  */
@@ -131,8 +131,8 @@ void exec_vcvt (void)
 #undef TEST_MSG
 #define TEST_MSG "VCVT/VCVTQ"
   fprintf(ref_file, "\n%s output:\n", TEST_MSG " (check rounding)");
-  TEST_VDUP(vector, , float, f, 32, 2, 10.4);
-  TEST_VDUP(vector, q, float, f, 32, 4, 125.9);
+  TEST_VDUP(vector, , float, f, 32, 2, 10.4f);
+  TEST_VDUP(vector, q, float, f, 32, 4, 125.9f);
   /* vcvt_xx_f32 */
   TEST_VCVT(, int, s, 32, 2, float, f);
   TEST_VCVT(, uint, u, 32, 2, float, f);
diff --git a/ref_vext.c b/ref_vext.c
index a14a5ac..aa00d81 100644
--- a/ref_vext.c
+++ b/ref_vext.c
@@ -63,7 +63,7 @@ void exec_vext (void)
   TEST_VDUP(vector2, , uint, u, 16, 4, 0x66);
   TEST_VDUP(vector2, , uint, u, 32, 2, 0x77);
   TEST_VDUP(vector2, , uint, u, 64, 1, 0x88);
-  TEST_VDUP(vector2, , float, f, 32, 2, 33.6);
+  TEST_VDUP(vector2, , float, f, 32, 2, 33.6f);
 
   TEST_VDUP(vector2, q, int, s, 8, 16, 0x11);
   TEST_VDUP(vector2, q, int, s, 16, 8, 0x22);
@@ -73,7 +73,7 @@ void exec_vext (void)
   TEST_VDUP(vector2, q, uint, u, 16, 8, 0x66);
   TEST_VDUP(vector2, q, uint, u, 32, 4, 0x77);
   TEST_VDUP(vector2, q, uint, u, 64, 2, 0x88);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 33.2);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 33.2f);
 
   /* Choose arbitrary extract offsets */
   TEST_VEXT(, int, s, 8, 8, 7);
diff --git a/ref_vmax.c b/ref_vmax.c
index a2a6b60..d1e12b7 100644
--- a/ref_vmax.c
+++ b/ref_vmax.c
@@ -82,8 +82,8 @@ FNNAME (INSN_NAME)
   TEST_VDUP(vector2, q, uint, u, 16, 8, 0xfff2);
   TEST_VDUP(vector2, q, uint, u, 32, 4, 0xfffffff1);
 #ifndef NO_FLOAT_VARIANT
-  TEST_VDUP(vector2, , float, f, 32, 2, -15.5);
-  TEST_VDUP(vector2, q, float, f, 32, 4, -14.5);
+  TEST_VDUP(vector2, , float, f, 32, 2, -15.5f);
+  TEST_VDUP(vector2, q, float, f, 32, 4, -14.5f);
 #endif
 
 #ifndef NO_FLOAT_VARIANT
diff --git a/ref_vmla.c b/ref_vmla.c
index 2b2a42b..c7b3939 100644
--- a/ref_vmla.c
+++ b/ref_vmla.c
@@ -101,14 +101,14 @@ FNNAME (INSN_NAME)
   TEST_VDUP(vector2, , uint, u, 8, 8, 0x44);
   TEST_VDUP(vector2, , uint, u, 16, 4, 0x55);
   TEST_VDUP(vector2, , uint, u, 32, 2, 0x66);
-  TEST_VDUP(vector2, , float, f, 32, 2, 33.1);
+  TEST_VDUP(vector2, , float, f, 32, 2, 33.1f);
   TEST_VDUP(vector2, q, int, s, 8, 16, 0x77);
   TEST_VDUP(vector2, q, int, s, 16, 8, 0x88);
   TEST_VDUP(vector2, q, int, s, 32, 4, 0x99);
   TEST_VDUP(vector2, q, uint, u, 8, 16, 0xAA);
   TEST_VDUP(vector2, q, uint, u, 16, 8, 0xBB);
   TEST_VDUP(vector2, q, uint, u, 32, 4, 0xCC);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 99.2);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 99.2f);
 
   TEST_VDUP(vector3, , int, s, 8, 8, 0xFF);
   TEST_VDUP(vector3, , int, s, 16, 4, 0xEE);
@@ -116,14 +116,14 @@ FNNAME (INSN_NAME)
   TEST_VDUP(vector3, , uint, u, 8, 8, 0xCC);
   TEST_VDUP(vector3, , uint, u, 16, 4, 0xBB);
   TEST_VDUP(vector3, , uint, u, 32, 2, 0xAA);
-  TEST_VDUP(vector3, , float, f, 32, 2, 10.23);
+  TEST_VDUP(vector3, , float, f, 32, 2, 10.23f);
   TEST_VDUP(vector3, q, int, s, 8, 16, 0x99);
   TEST_VDUP(vector3, q, int, s, 16, 8, 0x88);
   TEST_VDUP(vector3, q, int, s, 32, 4, 0x77);
   TEST_VDUP(vector3, q, uint, u, 8, 16, 0x66);
   TEST_VDUP(vector3, q, uint, u, 16, 8, 0x55);
   TEST_VDUP(vector3, q, uint, u, 32, 4, 0x44);
-  TEST_VDUP(vector3, q, float, f, 32, 4, 77.8);
+  TEST_VDUP(vector3, q, float, f, 32, 4, 77.8f);
 
   TEST_VMLX(INSN_NAME, , int, s, 8, 8);
   TEST_VMLX(INSN_NAME, , int, s, 16, 4);
diff --git a/ref_vmla_lane.c b/ref_vmla_lane.c
index b79d44c..79a54ed 100644
--- a/ref_vmla_lane.c
+++ b/ref_vmla_lane.c
@@ -96,18 +96,18 @@ FNNAME (INSN_NAME)
   TEST_VDUP(vector2, , int, s, 32, 2, 0x55);
   TEST_VDUP(vector2, , uint, u, 16, 4, 0x55);
   TEST_VDUP(vector2, , uint, u, 32, 2, 0x55);
-  TEST_VDUP(vector2, , float, f, 32, 2, 55.3);
+  TEST_VDUP(vector2, , float, f, 32, 2, 55.3f);
   TEST_VDUP(vector2, q, int, s, 16, 8, 0x55);
   TEST_VDUP(vector2, q, int, s, 32, 4, 0x55);
   TEST_VDUP(vector2, q, uint, u, 16, 8, 0x55);
   TEST_VDUP(vector2, q, uint, u, 32, 4, 0x55);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 55.8);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 55.8f);
 
   TEST_VDUP(vector3, , int, s, 16, 4, 0xBB);
   TEST_VDUP(vector3, , int, s, 32, 2, 0xBB);
   TEST_VDUP(vector3, , uint, u, 16, 4, 0xBB);
   TEST_VDUP(vector3, , uint, u, 32, 2, 0xBB);
-  TEST_VDUP(vector3, , float, f, 32, 2, 11.34);
+  TEST_VDUP(vector3, , float, f, 32, 2, 11.34f);
 
   /* Choose lane arbitrarily */
   TEST_VMLX_LANE(INSN_NAME, , int, s, 16, 4, 4, 2);
diff --git a/ref_vmla_n.c b/ref_vmla_n.c
index edcfc5e..f915092 100644
--- a/ref_vmla_n.c
+++ b/ref_vmla_n.c
@@ -89,24 +89,24 @@ FNNAME (INSN_NAME)
   TEST_VDUP(vector2, , int, s, 32, 2, 0x55);
   TEST_VDUP(vector2, , uint, u, 16, 4, 0x55);
   TEST_VDUP(vector2, , uint, u, 32, 2, 0x55);
-  TEST_VDUP(vector2, , float, f, 32, 2, 55.2);
+  TEST_VDUP(vector2, , float, f, 32, 2, 55.2f);
   TEST_VDUP(vector2, q, int, s, 16, 8, 0x55);
   TEST_VDUP(vector2, q, int, s, 32, 4, 0x55);
   TEST_VDUP(vector2, q, uint, u, 16, 8, 0x55);
   TEST_VDUP(vector2, q, uint, u, 32, 4, 0x55);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 55.9);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 55.9f);
 
   /* Choose multiplier arbitrarily */
   TEST_VMLX_N(INSN_NAME, , int, s, 16, 4, 0x11);
   TEST_VMLX_N(INSN_NAME, , int, s, 32, 2, 0x22);
   TEST_VMLX_N(INSN_NAME, , uint, u, 16, 4, 0x33);
   TEST_VMLX_N(INSN_NAME, , uint, u, 32, 2, 0x44);
-  TEST_VMLX_N(INSN_NAME, , float, f, 32, 2, 22.3);
+  TEST_VMLX_N(INSN_NAME, , float, f, 32, 2, 22.3f);
   TEST_VMLX_N(INSN_NAME, q, int, s, 16, 8, 0x55);
   TEST_VMLX_N(INSN_NAME, q, int, s, 32, 4, 0x66);
   TEST_VMLX_N(INSN_NAME, q, uint, u, 16, 8, 0x77);
   TEST_VMLX_N(INSN_NAME, q, uint, u, 32, 4, 0x88);
-  TEST_VMLX_N(INSN_NAME, q, float, f, 32, 4, 66.7);
+  TEST_VMLX_N(INSN_NAME, q, float, f, 32, 4, 66.7f);
 
   dump_results_hex (TEST_MSG);
 }
diff --git a/ref_vmul.c b/ref_vmul.c
index 7e77338..28d303f 100644
--- a/ref_vmul.c
+++ b/ref_vmul.c
@@ -99,14 +99,14 @@ FNNAME (INSN_NAME)
   TEST_VDUP(vector2, , uint, u, 8, 8, 0x44);
   TEST_VDUP(vector2, , uint, u, 16, 4, 0x55);
   TEST_VDUP(vector2, , uint, u, 32, 2, 0x66);
-  TEST_VDUP(vector2, , float, f, 32, 2, 33.3);
+  TEST_VDUP(vector2, , float, f, 32, 2, 33.3f);
   TEST_VDUP(vector2, q, int, s, 8, 16, 0x77);
   TEST_VDUP(vector2, q, int, s, 16, 8, 0x88);
   TEST_VDUP(vector2, q, int, s, 32, 4, 0x99);
   TEST_VDUP(vector2, q, uint, u, 8, 16, 0xAA);
   TEST_VDUP(vector2, q, uint, u, 16, 8, 0xBB);
   TEST_VDUP(vector2, q, uint, u, 32, 4, 0xCC);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 99.6);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 99.6f);
 
   TEST_VMUL(INSN_NAME, , int, s, 8, 8);
   TEST_VMUL(INSN_NAME, , int, s, 16, 4);
diff --git a/ref_vmul_lane.c b/ref_vmul_lane.c
index 650c9d9..34615a5 100644
--- a/ref_vmul_lane.c
+++ b/ref_vmul_lane.c
@@ -85,7 +85,7 @@ void exec_vmul_lane (void)
   TEST_VDUP(vector2, , int, s, 32, 2, 0x22);
   TEST_VDUP(vector2, , uint, u, 16, 4, 0x444);
   TEST_VDUP(vector2, , uint, u, 32, 2, 0x532);
-  TEST_VDUP(vector2, , float, f, 32, 2, 22.8);
+  TEST_VDUP(vector2, , float, f, 32, 2, 22.8f);
 
   /* Choose lane arbitrarily */
   TEST_VMUL_LANE(, int, s, 16, 4, 4, 2);
diff --git a/ref_vmul_n.c b/ref_vmul_n.c
index 628862d..356a062 100644
--- a/ref_vmul_n.c
+++ b/ref_vmul_n.c
@@ -78,12 +78,12 @@ void exec_vmul_n (void)
   TEST_VMUL_N(, int, s, 32, 2, 0x22);
   TEST_VMUL_N(, uint, u, 16, 4, 0x33);
   TEST_VMUL_N(, uint, u, 32, 2, 0x44);
-  TEST_VMUL_N(, float, f, 32, 2, 22.3);
+  TEST_VMUL_N(, float, f, 32, 2, 22.3f);
   TEST_VMUL_N(q, int, s, 16, 8, 0x55);
   TEST_VMUL_N(q, int, s, 32, 4, 0x66);
   TEST_VMUL_N(q, uint, u, 16, 8, 0x77);
   TEST_VMUL_N(q, uint, u, 32, 4, 0x88);
-  TEST_VMUL_N(q, float, f, 32, 4, 88.9);
+  TEST_VMUL_N(q, float, f, 32, 4, 88.9f);
 
   /* FIXME: only a subset of the result buffers are used, but we
      output all of them */
diff --git a/ref_vneg.c b/ref_vneg.c
index 4e9e68f..8b2206d 100644
--- a/ref_vneg.c
+++ b/ref_vneg.c
@@ -42,8 +42,8 @@ void exec_vneg_f32(void)
   DECL_VARIABLE(vector_res, float, 32, 2);
   DECL_VARIABLE(vector_res, float, 32, 4);
 
-  TEST_VDUP(vector, , float, f, 32, 2, 2.3);
-  TEST_VDUP(vector, q, float, f, 32, 4, 3.4);
+  TEST_VDUP(vector, , float, f, 32, 2, 2.3f);
+  TEST_VDUP(vector, q, float, f, 32, 4, 3.4f);
 
   TEST_UNARY_OP(INSN_NAME, , float, f, 32, 2);
   TEST_UNARY_OP(INSN_NAME, q, float, f, 32, 4);
diff --git a/ref_vrecpe.c b/ref_vrecpe.c
index 0a29ecc..41d314a 100644
--- a/ref_vrecpe.c
+++ b/ref_vrecpe.c
@@ -62,9 +62,9 @@ void exec_vrecpe(void)
 
   /* Choose init value arbitrarily */
   TEST_VDUP(vector, , uint, u, 32, 2, 0x12345678);
-  TEST_VDUP(vector, , float, f, 32, 2, 1.9);
+  TEST_VDUP(vector, , float, f, 32, 2, 1.9f);
   TEST_VDUP(vector, q, uint, u, 32, 4, 0xABCDEF10);
-  TEST_VDUP(vector, q, float, f, 32, 4, 125);
+  TEST_VDUP(vector, q, float, f, 32, 4, 125.0f);
 
   /* Apply the operator */
   TEST_VRECPE(, uint, u, 32, 2);
@@ -80,9 +80,9 @@ void exec_vrecpe(void)
 
   /* Choose init value arbitrarily */
   TEST_VDUP(vector, , uint, u, 32, 2, 0xFFFFFFFF);
-  TEST_VDUP(vector, , float, f, 32, 2, -10.0);
+  TEST_VDUP(vector, , float, f, 32, 2, -10.0f);
   TEST_VDUP(vector, q, uint, u, 32, 4, 0x89081234);
-  TEST_VDUP(vector, q, float, f, 32, 4, -125.0);
+  TEST_VDUP(vector, q, float, f, 32, 4, -125.0f);
 
   /* Apply the operator */
   TEST_VRECPE(, uint, u, 32, 2);
@@ -109,8 +109,8 @@ void exec_vrecpe(void)
   DUMP_FP(TEST_MSG, float, 32, 4, PRIx32);
 
   /* Test FP variants with special input values (zero, large value) */
-  TEST_VDUP(vector, , float, f, 32, 2, 0.0);
-  TEST_VDUP(vector, q, float, f, 32, 4, 9.0e37);
+  TEST_VDUP(vector, , float, f, 32, 2, 0.0f);
+  TEST_VDUP(vector, q, float, f, 32, 4, 9.0e37f);
 
   /* Apply the operator */
   TEST_VRECPE(, float, f, 32, 2);
@@ -121,7 +121,7 @@ void exec_vrecpe(void)
   DUMP_FP(TEST_MSG, float, 32, 4, PRIx32);
 
   /* Test FP variants with special input values (-0, -infinity) */
-  TEST_VDUP(vector, , float, f, 32, 2, -0.0);
+  TEST_VDUP(vector, , float, f, 32, 2, -0.0f);
   TEST_VDUP(vector, q, float, f, 32, 4, -HUGE_VALF);
 
   /* Apply the operator */
@@ -133,7 +133,7 @@ void exec_vrecpe(void)
   DUMP_FP(TEST_MSG, float, 32, 4, PRIx32);
 
   /* Test FP variants with special input values (large negative value) */
-  TEST_VDUP(vector, , float, f, 32, 2, -9.0e37);
+  TEST_VDUP(vector, , float, f, 32, 2, -9.0e37f);
 
   /* Apply the operator */
   TEST_VRECPE(, float, f, 32, 2);
diff --git a/ref_vrecps.c b/ref_vrecps.c
index 333fa07..8da3b43 100644
--- a/ref_vrecps.c
+++ b/ref_vrecps.c
@@ -60,11 +60,11 @@ void exec_vrecps(void)
   clean_results ();
 
   /* Choose init value arbitrarily */
-  TEST_VDUP(vector, , float, f, 32, 2, 12.9);
-  TEST_VDUP(vector, q, float, f, 32, 4, 9.2);
+  TEST_VDUP(vector, , float, f, 32, 2, 12.9f);
+  TEST_VDUP(vector, q, float, f, 32, 4, 9.2f);
 
-  TEST_VDUP(vector2, , float, f, 32, 2, 8.9);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 3.2);
+  TEST_VDUP(vector2, , float, f, 32, 2, 8.9f);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 3.2f);
 
   /* Apply the operator */
   TEST_VRECPS(, float, f, 32, 2);
diff --git a/ref_vrsqrte.c b/ref_vrsqrte.c
index 40da0ea..a7001d4 100644
--- a/ref_vrsqrte.c
+++ b/ref_vrsqrte.c
@@ -62,9 +62,9 @@ void exec_vrsqrte(void)
 
   /* Choose init value arbitrarily */
   TEST_VDUP(vector, , uint, u, 32, 2, 0x12345678);
-  TEST_VDUP(vector, , float, f, 32, 2, 25.799999);
+  TEST_VDUP(vector, , float, f, 32, 2, 25.799999f);
   TEST_VDUP(vector, q, uint, u, 32, 4, 0xABCDEF10);
-  TEST_VDUP(vector, q, float, f, 32, 4, 18.2);
+  TEST_VDUP(vector, q, float, f, 32, 4, 18.2f);
 
   /* Apply the operator */
   TEST_VRSQRTE(, uint, u, 32, 2);
@@ -106,7 +106,7 @@ void exec_vrsqrte(void)
 
   /* Test FP variants with special input values (NaNs, ...) */
   TEST_VDUP(vector, , float, f, 32, 2, NAN);
-  TEST_VDUP(vector, q, float, f, 32, 4, 0.0);
+  TEST_VDUP(vector, q, float, f, 32, 4, 0.0f);
 
   /* Apply the operator */
   TEST_VRSQRTE(, float, f, 32, 2);
@@ -117,7 +117,7 @@ void exec_vrsqrte(void)
   DUMP_FP(TEST_MSG, float, 32, 4, PRIx32);
 
   /* Test FP variants with special input values (negative, infinity) */
-  TEST_VDUP(vector, , float, f, 32, 2, -1.0);
+  TEST_VDUP(vector, , float, f, 32, 2, -1.0f);
   TEST_VDUP(vector, q, float, f, 32, 4, HUGE_VALF);
 
   /* Apply the operator */
@@ -129,7 +129,7 @@ void exec_vrsqrte(void)
   DUMP_FP(TEST_MSG, float, 32, 4, PRIx32);
 
   /* Test FP variants with special input values (-0, -infinity) */
-  TEST_VDUP(vector, , float, f, 32, 2, -0.0);
+  TEST_VDUP(vector, , float, f, 32, 2, -0.0f);
   TEST_VDUP(vector, q, float, f, 32, 4, -HUGE_VALF);
 
   /* Apply the operator */
diff --git a/ref_vrsqrts.c b/ref_vrsqrts.c
index a3f3d00..e8521ca 100644
--- a/ref_vrsqrts.c
+++ b/ref_vrsqrts.c
@@ -60,11 +60,11 @@ void exec_vrsqrts(void)
   clean_results ();
 
   /* Choose init value arbitrarily */
-  TEST_VDUP(vector, , float, f, 32, 2, 12.9);
-  TEST_VDUP(vector, q, float, f, 32, 4, 9.1);
+  TEST_VDUP(vector, , float, f, 32, 2, 12.9f);
+  TEST_VDUP(vector, q, float, f, 32, 4, 9.1f);
 
-  TEST_VDUP(vector2, , float, f, 32, 2, 9.9);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 1.9);
+  TEST_VDUP(vector2, , float, f, 32, 2, 9.9f);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 1.9f);
 
   /* Apply the operator */
   TEST_VRSQRTS(, float, f, 32, 2);
diff --git a/ref_vset_lane.c b/ref_vset_lane.c
index a938469..82f3584 100644
--- a/ref_vset_lane.c
+++ b/ref_vset_lane.c
@@ -62,7 +62,7 @@ void exec_vset_lane (void)
   TEST_VSET_LANE_HERE(, uint, u, 16, 4, 0x66, 2);
   TEST_VSET_LANE_HERE(, uint, u, 32, 2, 0x77, 1);
   TEST_VSET_LANE_HERE(, uint, u, 64, 1, 0x88, 0);
-  TEST_VSET_LANE_HERE(, float, f, 32, 2, 33.2, 1);
+  TEST_VSET_LANE_HERE(, float, f, 32, 2, 33.2f, 1);
 
   TEST_VSET_LANE_HERE(q, int, s, 8, 16, 0x99, 15);
   TEST_VSET_LANE_HERE(q, int, s, 16, 8, 0xAA, 5);
@@ -72,7 +72,7 @@ void exec_vset_lane (void)
   TEST_VSET_LANE_HERE(q, uint, u, 16, 8, 0xEE, 6);
   TEST_VSET_LANE_HERE(q, uint, u, 32, 4, 0xFF, 2);
   TEST_VSET_LANE_HERE(q, uint, u, 64, 2, 0x11, 1);
-  TEST_VSET_LANE_HERE(q, float, f, 32, 4, 11.2, 3);
+  TEST_VSET_LANE_HERE(q, float, f, 32, 4, 11.2f, 3);
 
   dump_results_hex (TEST_MSG);
 }
diff --git a/ref_vsub.c b/ref_vsub.c
index 1f81cd0..4b697d4 100644
--- a/ref_vsub.c
+++ b/ref_vsub.c
@@ -45,11 +45,11 @@ void exec_vsub_f32(void)
   DECL_VARIABLE(vector_res, float, 32, 2);
   DECL_VARIABLE(vector_res, float, 32, 4);
 
-  TEST_VDUP(vector, , float, f, 32, 2, 2.3);
-  TEST_VDUP(vector, q, float, f, 32, 4, 3.4);
+  TEST_VDUP(vector, , float, f, 32, 2, 2.3f);
+  TEST_VDUP(vector, q, float, f, 32, 4, 3.4f);
 
-  TEST_VDUP(vector2, , float, f, 32, 2, 4.5);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 5.6);
+  TEST_VDUP(vector2, , float, f, 32, 2, 4.5f);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 5.6f);
 
   TEST_BINARY_OP(INSN_NAME, , float, f, 32, 2);
   TEST_BINARY_OP(INSN_NAME, q, float, f, 32, 4);
diff --git a/ref_vuzp.c b/ref_vuzp.c
index aa5854d..5bc7be9 100644
--- a/ref_vuzp.c
+++ b/ref_vuzp.c
@@ -102,7 +102,7 @@ FNNAME (INSN_NAME)
   TEST_VDUP(vector2, , uint, u, 8, 8, 0x55);
   TEST_VDUP(vector2, , uint, u, 16, 4, 0x66);
   TEST_VDUP(vector2, , uint, u, 32, 2, 0x77);
-  TEST_VDUP(vector2, , float, f, 32, 2, 33.6);
+  TEST_VDUP(vector2, , float, f, 32, 2, 33.6f);
 
   TEST_VDUP(vector2, q, int, s, 8, 16, 0x11);
   TEST_VDUP(vector2, q, int, s, 16, 8, 0x22);
@@ -110,7 +110,7 @@ FNNAME (INSN_NAME)
   TEST_VDUP(vector2, q, uint, u, 8, 16, 0x55);
   TEST_VDUP(vector2, q, uint, u, 16, 8, 0x66);
   TEST_VDUP(vector2, q, uint, u, 32, 4, 0x77);
-  TEST_VDUP(vector2, q, float, f, 32, 4, 33.8);
+  TEST_VDUP(vector2, q, float, f, 32, 4, 33.8f);
 
 #define TEST_ALL_VUZP(INSN)			\
   TEST_VUZP(INSN, , int, s, 8, 8);		\