OSDN Git Service

2006-11-24 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
authormanu <manu@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 24 Nov 2006 01:50:33 +0000 (01:50 +0000)
committermanu <manu@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 24 Nov 2006 01:50:33 +0000 (01:50 +0000)
PR c/2707
PR c++/26167
* c-common.c (conversion_warning): New.
(convert_and_check): Call conversion_warning unless there is an
overflow warning.
* doc/invoke.texi (-Wconversion): Update description.

testsuite/

* gcc.dg/Wconversion-integer.c: New. Supersedes
Wconversion-negative-constants.c
* gcc.dg/Wconversion-real.c: New.
* gcc.dg/Wconversion-real-integer.c: New.
* gcc.dg/Wconversion-negative-constants.c: Deleted.
* g++.dg/warn/Wconversion1.C: Modified.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@119143 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/c-common.c
gcc/doc/invoke.texi
gcc/testsuite/ChangeLog
gcc/testsuite/g++.dg/warn/Wconversion1.C
gcc/testsuite/gcc.dg/Wconversion-integer.c [new file with mode: 0644]
gcc/testsuite/gcc.dg/Wconversion-negative-constants.c [deleted file]
gcc/testsuite/gcc.dg/Wconversion-real-integer.c [new file with mode: 0644]
gcc/testsuite/gcc.dg/Wconversion-real.c [new file with mode: 0644]

index 5258b59..d5dfb09 100644 (file)
@@ -1,3 +1,12 @@
+2006-11-24  Manuel Lopez-Ibanez <manu@gcc.gnu.org>
+
+       PR c/2707
+       PR c++/26167
+       * c-common.c (conversion_warning): New.
+       (convert_and_check): Call conversion_warning unless there is an
+       overflow warning.
+       * doc/invoke.texi (-Wconversion): Update description.
+
 2006-11-23  Daniel Berlin  <dberlin@dberlin.org>
 
        * tree-ssa-alias.c (tree_pointer_compare): New function.
index 0603da6..8e4cbff 100644 (file)
@@ -1127,6 +1127,113 @@ vector_types_convertible_p (tree t1, tree t2)
                == INTEGRAL_TYPE_P (TREE_TYPE (t2)));
 }
 
+/* Warns if the conversion of EXPR to TYPE may alter a value.
+   This function is called from convert_and_check.  */
+
+static void
+conversion_warning (tree type, tree expr)
+{
+  bool give_warning = false;
+
+  unsigned int formal_prec = TYPE_PRECISION (type);
+
+  if (TREE_CODE (expr) == REAL_CST || TREE_CODE (expr) == INTEGER_CST)
+    {
+      /* Warn for real constant that is not an exact integer converted
+         to integer type.  */
+      if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
+          && TREE_CODE (type) == INTEGER_TYPE)
+        {
+          if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (TREE_TYPE (expr))))
+            give_warning = true;
+        }
+      /* Warn for an integer constant that does not fit into integer
+         type. However, warnings for negative constants converted to
+         unsigned types are detected by unsigned_conversion_warning.  */
+      else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
+               && TREE_CODE (type) == INTEGER_TYPE
+               && !int_fits_type_p (expr, type)
+               && !(TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr))))
+        give_warning = true;
+
+      else if (TREE_CODE (type) == REAL_TYPE)
+        {
+          /* Warn for an integer constant that does not fit into real type.  */
+          if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE)
+            {
+              REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
+              if (!exact_real_truncate (TYPE_MODE (type), &a))
+                give_warning = true;
+            }
+          /* Warn for a real constant that does not fit into a smaller
+             real type.  */
+          else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
+                   && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
+            {
+              REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
+              if (!exact_real_truncate (TYPE_MODE (type), &a))
+                give_warning = true;
+            }
+        }
+
+      if (give_warning)
+        warning (OPT_Wconversion,
+                 "conversion to %qT alters %qT constant value",
+                 type, TREE_TYPE (expr));
+    }
+  else /* 'expr' is not a constant.  */
+    {
+      /* Warn for real types converted to integer types.  */
+      if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
+          && TREE_CODE (type) == INTEGER_TYPE)
+        give_warning = true;
+
+      else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
+               && TREE_CODE (type) == INTEGER_TYPE)
+        {
+          /* Warn for integer types converted to smaller integer types.  */
+          if (formal_prec < TYPE_PRECISION (TREE_TYPE (expr))
+              /* When they are the same width but different signedness,
+                 then the value may change.  */
+              || (formal_prec == TYPE_PRECISION (TREE_TYPE (expr))
+                  && TYPE_UNSIGNED (TREE_TYPE (expr)) != TYPE_UNSIGNED (type))
+              /* Even when converted to a bigger type, if the type is
+                 unsigned but expr is signed, then negative values
+                 will be changed.  */
+              || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr))))
+            give_warning = true;
+        }
+
+      /* Warn for integer types converted to real types if and only if
+         all the range of values of the integer type cannot be
+         represented by the real type.  */
+      else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
+               && TREE_CODE (type) == REAL_TYPE)
+        {
+          tree type_low_bound = TYPE_MIN_VALUE (TREE_TYPE (expr));
+          tree type_high_bound = TYPE_MAX_VALUE (TREE_TYPE (expr));
+          REAL_VALUE_TYPE real_low_bound = real_value_from_int_cst (0, type_low_bound);
+          REAL_VALUE_TYPE real_high_bound = real_value_from_int_cst (0, type_high_bound);
+
+          if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
+              || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
+            give_warning = true;
+        }
+
+      /* Warn for real types converted to smaller real types.  */
+      else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
+               && TREE_CODE (type) == REAL_TYPE
+               && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
+        give_warning = true;
+
+
+      if (give_warning)
+        warning (OPT_Wconversion,
+                 "conversion to %qT from %qT may alter its value",
+                 type, TREE_TYPE (expr));
+    }
+}
+
 /* Convert EXPR to TYPE, warning about conversion problems with constants.
    Invoke this function on every expression that is converted implicitly,
    i.e. because of language rules and not because of an explicit cast.  */
@@ -1135,33 +1242,39 @@ tree
 convert_and_check (tree type, tree expr)
 {
   tree t = convert (type, expr);
-  if (TREE_CODE (t) == INTEGER_CST)
+  if (TREE_CODE (t) == INTEGER_CST && TREE_OVERFLOW (t))
+    {
+      TREE_OVERFLOW (t) = 0;
+
+      /* Do not diagnose overflow in a constant expression merely
+         because a conversion overflowed.  */
+      TREE_CONSTANT_OVERFLOW (t) = CONSTANT_CLASS_P (expr)
+        && TREE_CONSTANT_OVERFLOW (expr);
+      
+      /* No warning for converting 0x80000000 to int.  */
+      if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
+            && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
+            && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
+        {
+          /* If EXPR fits in the unsigned version of TYPE,
+             don't warn unless pedantic.  */
+          if ((pedantic
+               || TYPE_UNSIGNED (type)
+               || !constant_fits_type_p (expr,
+                                         c_common_unsigned_type (type)))
+              && skip_evaluation == 0)
+            warning (OPT_Woverflow,
+                     "overflow in implicit constant conversion");
+        }
+      else if (warn_conversion && !skip_evaluation)
+          conversion_warning (type, expr);
+    }
+  else 
     {
-      if (TREE_OVERFLOW (t))
-       {
-         TREE_OVERFLOW (t) = 0;
-
-         /* Do not diagnose overflow in a constant expression merely
-            because a conversion overflowed.  */
-         TREE_CONSTANT_OVERFLOW (t) = CONSTANT_CLASS_P (expr)
-                                       && TREE_CONSTANT_OVERFLOW (expr);
-
-         /* No warning for converting 0x80000000 to int.  */
-         if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
-               && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
-               && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
-           /* If EXPR fits in the unsigned version of TYPE,
-              don't warn unless pedantic.  */
-           if ((pedantic
-                || TYPE_UNSIGNED (type)
-                || !constant_fits_type_p (expr,
-                                          c_common_unsigned_type (type)))
-               && skip_evaluation == 0)
-             warning (OPT_Woverflow,
-                       "overflow in implicit constant conversion");
-       }
-      else
-       unsigned_conversion_warning (t, expr);
+      if (warn_conversion && !skip_evaluation)
+        conversion_warning (type, expr);
+
+      unsigned_conversion_warning (t, expr);
     }
   return t;
 }
index 9f22681..c987721 100644 (file)
@@ -3156,10 +3156,13 @@ this is why we did not make @option{-Wall} request these warnings.
 
 @item -Wconversion
 @opindex Wconversion
-Warn if a negative integer constant expression is implicitly converted
-to an unsigned type.  For example, warn about the assignment
-@code{unsigned x = -1} if @code{x} is unsigned. But do not warn about
-explicit casts like @code{(unsigned) -1}.
+Warn for implicit conversions that may alter a value. This includes
+conversions between real and integer, like @code{abs (x)} when
+@code{x} is @code{double}; conversions between signed and unsigned,
+like @code{unsigned ui = -1}; and conversions to smaller types, like
+@code{sqrtf (M_PI)}. Do not warn for explicit casts like @code{abs
+((int) x)} and @code{ui = (unsigned) -1}, or if the value is not
+changed by the conversion like in @code{abs (2.0)}.
 
 @item -Wsign-compare
 @opindex Wsign-compare
index d614368..6c6c933 100644 (file)
@@ -1,3 +1,14 @@
+2006-11-24  Manuel Lopez-Ibanez <manu@gcc.gnu.org>
+
+       PR c/2707
+       PR c++/26167
+       * gcc.dg/Wconversion-integer.c: New. Supersedes 
+       Wconversion-negative-constants.c 
+       * gcc.dg/Wconversion-real.c: New.
+       * gcc.dg/Wconversion-real-integer.c: New.
+       * gcc.dg/Wconversion-negative-constants.c: Deleted.
+       * g++.dg/warn/Wconversion1.C: Modified.
+       
 2006-11-23  Tobias Schlueter  <tobias.schlueter@physik.uni-muenchen.de>
 
        * gfortran.dg/overload_1.f90: New test.
index 203b90e..8a20929 100644 (file)
@@ -9,4 +9,4 @@ unsigned char uc1 = -129; // { dg-warning "unsigned" }
 
 bool b1 = -3;
 
-int i1 = 0x80000000;
+int i1 = 0x80000000; // { dg-warning "conversion" }
diff --git a/gcc/testsuite/gcc.dg/Wconversion-integer.c b/gcc/testsuite/gcc.dg/Wconversion-integer.c
new file mode 100644 (file)
index 0000000..bab8062
--- /dev/null
@@ -0,0 +1,95 @@
+/* Test for diagnostics for implicit conversions between integer types
+   These tests come from gcc/testsuite/gcc.dg/overflow-warn-2.c  */
+
+/* { dg-do compile } */
+/* { dg-options "-std=c99 -Wconversion" } */
+
+#include <limits.h>
+
+void fsc (signed char sc);
+void fuc (unsigned char uc);
+unsigned fui (unsigned int  ui);
+void fsi (signed int ui);
+
+void h (int x)
+{
+  unsigned int ui = 3;
+  int   si = 3;
+  unsigned char uc = 3;
+  signed char   sc = 3;
+
+  fuc (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  fuc ('\xa0'); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = '\xa0'; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  uc = x ? 1U : -1; /* { dg-warning "conversion" } */
+  /* { dg-warning "negative integer implicitly converted to unsigned type" "" { target *-*-* } 25 } */
+  uc = x ? SCHAR_MIN : 1U; /* { dg-warning "conversion" } */
+  /* { dg-warning "negative integer implicitly converted to unsigned type" "" { target *-*-* } 27 } */
+
+  uc = x ? 1 : -1; /* { dg-warning "conversion" } */
+
+  uc = x ? SCHAR_MIN : 1; /* { dg-warning "conversion" } */
+
+  fuc ('A');
+  uc = 'A';
+  uc = (unsigned char) -1;
+
+  fui (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = x ? INT_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = ui ? SCHAR_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = 1U * -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = ui + INT_MIN; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = x ? 1 : -1; /* { dg-warning "conversion" } */
+  ui = ui ? SCHAR_MIN : 1; /* { dg-warning "conversion" } */
+
+  ui = -1 * (1 * -1);
+  ui = (unsigned) -1;
+
+  fsc (uc); /* { dg-warning "conversion" } */
+  sc = uc;  /* { dg-warning "conversion" } */
+  fuc (sc); /* { dg-warning "conversion" } */
+  uc = sc;  /* { dg-warning "conversion" } */
+  fsi (ui); /* { dg-warning "conversion" } */
+  si = ui;  /* { dg-warning "conversion" } */
+  fui (si); /* { dg-warning "conversion" } */ 
+  ui = si;  /* { dg-warning "conversion" } */ 
+  fui (sc); /* { dg-warning "conversion" } */
+  ui = sc;  /* { dg-warning "conversion" } */
+
+  fui ('\xa0');/* { dg-warning "negative integer implicitly converted to unsigned type" } */
+  ui = '\xa0'; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+
+  fsi (si);
+  fui (ui);
+  fsi (uc);
+  si = uc;
+  fui (uc);
+  ui = uc;
+  fui ('A');
+  ui = 'A';
+  fsi ('A');
+  si = 'A';
+  
+
+  fsi (UINT_MAX - 1);  /* { dg-warning "conversion" } */
+  si = UINT_MAX - 1;   /* { dg-warning "conversion" } */
+  fsi (UINT_MAX - 1U); /* { dg-warning "conversion" } */
+  si = UINT_MAX - 1U;  /* { dg-warning "conversion" } */
+  fsi (UINT_MAX/3U);
+  si = UINT_MAX/3U;
+  fsi (UINT_MAX/3);
+  si = UINT_MAX/3;
+  fui (UINT_MAX - 1);
+  ui = UINT_MAX - 1;
+
+  fsi (0x80000000); /* { dg-warning "conversion" } */
+  si = 0x80000000;  /* { dg-warning "conversion" } */
+}
+
+
+unsigned fui (unsigned a) { return a + -1; } /* { dg-warning "negative integer implicitly converted to unsigned type" } */
+
+
diff --git a/gcc/testsuite/gcc.dg/Wconversion-negative-constants.c b/gcc/testsuite/gcc.dg/Wconversion-negative-constants.c
deleted file mode 100644 (file)
index 80ef410..0000000
+++ /dev/null
@@ -1,54 +0,0 @@
-/* Test for diagnostics for negative constants converted to unsigned types.
-   These tests come from gcc/testsuite/gcc.dg/overflow-warn-2.c  */
-
-/* { dg-do compile } */
-/* { dg-options "-std=c99 -Wconversion" } */
-
-#include <limits.h>
-
-void fuc (unsigned char);
-
-void hc (int x)
-{
-  unsigned char uc;
-
-  fuc (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-  uc = -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-  uc = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-  uc = x ? SCHAR_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-  uc = '\xa0'; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-
-  fuc('A');
-  uc = 'A';
-
-  uc = x ? 1 : -1;
-
-  uc = x ? SCHAR_MIN : 1;
-}
-
-unsigned fui (unsigned int ui);
-
-void hi (int x)
-{
-  unsigned ui;
-
-  fui (-1); /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-  ui = -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-  ui = x ? 1U : -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-  ui = x ? INT_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-  ui = ui ? SCHAR_MIN : 1U; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-  ui = 1U * -1; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-  ui = ui + INT_MIN; /* { dg-warning "negative integer implicitly converted to unsigned type" } */
-
-  ui = -1 * (1 * -1);
-  ui = (unsigned) -1;
-
-  ui = x ? 1 : -1;
-
-  ui = x ? INT_MIN : 1;
-
-  ui = ui ? SCHAR_MIN : 1;
-}
-
-
-unsigned fui(unsigned a) { return a + -1; } /* { dg-warning "negative integer implicitly converted to unsigned type" } */
diff --git a/gcc/testsuite/gcc.dg/Wconversion-real-integer.c b/gcc/testsuite/gcc.dg/Wconversion-real-integer.c
new file mode 100644 (file)
index 0000000..5911f6a
--- /dev/null
@@ -0,0 +1,72 @@
+/* Test for diagnostics for Wconversion between floating-point and
+   integers.  */
+
+/* { dg-do compile }
+/* { dg-options "-std=c99 -Wconversion" } */
+
+#include <limits.h>
+
+void fsi (signed int x);
+void fui (unsigned int x);
+void ffloat (float x);
+void fdouble (double x);
+
+float  vfloat;
+double vdouble;
+
+void h (void)
+{
+  unsigned int ui = 3;
+  int   si = 3;
+  unsigned char uc = 3;
+  signed char sc = 3;
+  float  f = 3;
+  double d = 3;
+
+  fsi (3.1f); /* { dg-warning "conversion" } */
+  si = 3.1f; /* { dg-warning "conversion" } */
+  fsi (3.1);  /* { dg-warning "conversion" } */
+  si = 3.1;  /* { dg-warning "conversion" } */
+  fsi (d);    /* { dg-warning "conversion" } */
+  si = d;    /* { dg-warning "conversion" } */
+  fui (-1.0); /* { dg-warning "overflow" } */
+  ui = -1.0;   /* { dg-warning "overflow" } */
+  ffloat (INT_MAX);  /* { dg-warning "conversion" } */
+  vfloat = INT_MAX;  /* { dg-warning "conversion" } */
+  ffloat (16777217); /* { dg-warning "conversion" } */
+  vfloat = 16777217; /* { dg-warning "conversion" } */
+  ffloat (si); /* { dg-warning "conversion" } */
+  vfloat = si; /* { dg-warning "conversion" } */
+  ffloat (ui); /* { dg-warning "conversion" } */
+  vfloat = ui; /* { dg-warning "conversion" } */
+
+  fsi (3);
+  si = 3;
+  fsi (3.0f);
+  si = 3.0f;
+  fsi (3.0);
+  si = 3.0;
+  fsi (16777217.0f);
+  si = 16777217.0f;
+  fsi ((int) 3.1);
+  si = (int) 3.1;
+  ffloat (3U);
+  vfloat = 3U;
+  ffloat (3);
+  vfloat = 3;
+  ffloat (INT_MIN);
+  vfloat = INT_MIN;
+  ffloat (uc);
+  vfloat = uc;
+  ffloat (sc);
+  vfloat = sc;
+
+  fdouble (UINT_MAX);
+  vdouble = UINT_MAX;
+  fdouble (ui);
+  vdouble = ui;
+  fdouble (si);
+  vdouble = si;
+}
+
+
diff --git a/gcc/testsuite/gcc.dg/Wconversion-real.c b/gcc/testsuite/gcc.dg/Wconversion-real.c
new file mode 100644 (file)
index 0000000..53ac9a7
--- /dev/null
@@ -0,0 +1,84 @@
+/* Test for diagnostics for Wconversion for floating-point.  */
+
+/* { dg-do compile }
+/* { dg-options "-std=c99 -Wconversion" } */
+
+float  vfloat;
+double vdouble;
+long double vlongdouble;
+
+void ffloat (float f);
+void fdouble (double d);
+void flongdouble (long double ld);
+
+void h (void)
+{
+  float f = 0;
+  double d = 0;
+  long double ld = 0;
+
+  ffloat (3.1); /* { dg-warning "conversion" } */
+  vfloat = 3.1; /* { dg-warning "conversion" } */
+  ffloat (3.1L); /* { dg-warning "conversion" } */
+  vfloat = 3.1L; /* { dg-warning "conversion" } */
+  fdouble (3.1L); /* { dg-warning "conversion" } */
+  vdouble = 3.1L; /* { dg-warning "conversion" } */
+  ffloat (vdouble); /* { dg-warning "conversion" } */
+  vfloat = vdouble; /* { dg-warning "conversion" } */
+  ffloat (vlongdouble); /* { dg-warning "conversion" } */
+  vfloat = vlongdouble; /* { dg-warning "conversion" } */
+  fdouble (vlongdouble); /* { dg-warning "conversion" } */
+  vdouble = vlongdouble; /* { dg-warning "conversion" } */
+
+
+  ffloat ((float) 3.1); 
+  vfloat = (float) 3.1;
+  ffloat ((float) 3.1L);
+  vfloat = (float) 3.1L; 
+  fdouble ((double) 3.1L); 
+  vdouble = (double) 3.1L; 
+  ffloat ((float) vdouble); 
+  vfloat = (float) vdouble; 
+  ffloat ((float) vlongdouble); 
+  vfloat = (float) vlongdouble;
+  fdouble ((double) vlongdouble);
+  vdouble = (double) vlongdouble;
+
+
+  ffloat (3.0);
+  vfloat = 3.0;
+  ffloat (3.1f);
+  vfloat = 3.1f;
+  ffloat (0.25L);
+  vfloat = 0.25L;
+
+
+  fdouble (3.0);
+  vdouble = 3.0;
+  fdouble (3.1f);
+  vdouble = 3.1f;
+  fdouble (0.25L);
+  vdouble = 0.25L;
+
+  flongdouble (3.0);
+  vlongdouble = 3.0;
+  flongdouble (3.1f);
+  vlongdouble = 3.1f;
+  flongdouble (0.25L);
+  vlongdouble = 0.25L;
+
+  ffloat (f);
+  vfloat = f;
+  fdouble (f);
+  vdouble = f;
+  fdouble (d);
+  vdouble = d;
+  flongdouble (f);
+  vlongdouble = f;
+  flongdouble (d);
+  vlongdouble = d;
+  flongdouble (ld);
+  vlongdouble = ld;
+}
+
+