gcc/testsuite/gcc.target/i386/iamcu/test_passing_floats.c

   1 #include "defines.h"
   2 #include "macros.h"
   3 #include "args.h"
   4
   5 struct IntegerRegisters iregbits = { ~0, ~0, ~0, ~0, ~0, ~0 };
   6 struct IntegerRegisters iregs;
   7 unsigned int num_iregs;
   8
   9 /* This struct holds values for argument checking.  */
  10 struct
  11 {
  12   float f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23;
  13 } values_float;
  14
  15 struct
  16 {
  17   double f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23;
  18 } values_double;
  19
  20 struct
  21 {
  22   ldouble f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23;
  23 } values_ldouble;
  24
  25 void
  26 fun_check_float_passing_float8_values (float f0 ATTRIBUTE_UNUSED, float f1 ATTRIBUTE_UNUSED, float f2 ATTRIBUTE_UNUSED, float f3 ATTRIBUTE_UNUSED, float f4 ATTRIBUTE_UNUSED, float f5 ATTRIBUTE_UNUSED, float f6 ATTRIBUTE_UNUSED, float f7 ATTRIBUTE_UNUSED)
  27 {
  28   /* Check argument values.  */
  29   assert (values_float.f0 == f0);
  30   assert (values_float.f1 == f1);
  31   assert (values_float.f2 == f2);
  32   assert (values_float.f3 == f3);
  33   assert (values_float.f4 == f4);
  34   assert (values_float.f5 == f5);
  35   assert (values_float.f6 == f6);
  36   assert (values_float.f7 == f7);
  37
  38 }
  39
  40 void
  41 fun_check_float_passing_float8_regs (float f0 ATTRIBUTE_UNUSED, float f1 ATTRIBUTE_UNUSED, float f2 ATTRIBUTE_UNUSED, float f3 ATTRIBUTE_UNUSED, float f4 ATTRIBUTE_UNUSED, float f5 ATTRIBUTE_UNUSED, float f6 ATTRIBUTE_UNUSED, float f7 ATTRIBUTE_UNUSED)
  42 {
  43   /* Check register contents.  */
  44   check_float_arguments;
  45 }
  46
  47 void
  48 fun_check_float_passing_float16_values (float f0 ATTRIBUTE_UNUSED, float f1 ATTRIBUTE_UNUSED, float f2 ATTRIBUTE_UNUSED, float f3 ATTRIBUTE_UNUSED, float f4 ATTRIBUTE_UNUSED, float f5 ATTRIBUTE_UNUSED, float f6 ATTRIBUTE_UNUSED, float f7 ATTRIBUTE_UNUSED, float f8 ATTRIBUTE_UNUSED, float f9 ATTRIBUTE_UNUSED, float f10 ATTRIBUTE_UNUSED, float f11 ATTRIBUTE_UNUSED, float f12 ATTRIBUTE_UNUSED, float f13 ATTRIBUTE_UNUSED, float f14 ATTRIBUTE_UNUSED, float f15 ATTRIBUTE_UNUSED)
  49 {
  50   /* Check argument values.  */
  51   assert (values_float.f0 == f0);
  52   assert (values_float.f1 == f1);
  53   assert (values_float.f2 == f2);
  54   assert (values_float.f3 == f3);
  55   assert (values_float.f4 == f4);
  56   assert (values_float.f5 == f5);
  57   assert (values_float.f6 == f6);
  58   assert (values_float.f7 == f7);
  59   assert (values_float.f8 == f8);
  60   assert (values_float.f9 == f9);
  61   assert (values_float.f10 == f10);
  62   assert (values_float.f11 == f11);
  63   assert (values_float.f12 == f12);
  64   assert (values_float.f13 == f13);
  65   assert (values_float.f14 == f14);
  66   assert (values_float.f15 == f15);
  67
  68 }
  69
  70 void
  71 fun_check_float_passing_float16_regs (float f0 ATTRIBUTE_UNUSED, float f1 ATTRIBUTE_UNUSED, float f2 ATTRIBUTE_UNUSED, float f3 ATTRIBUTE_UNUSED, float f4 ATTRIBUTE_UNUSED, float f5 ATTRIBUTE_UNUSED, float f6 ATTRIBUTE_UNUSED, float f7 ATTRIBUTE_UNUSED, float f8 ATTRIBUTE_UNUSED, float f9 ATTRIBUTE_UNUSED, float f10 ATTRIBUTE_UNUSED, float f11 ATTRIBUTE_UNUSED, float f12 ATTRIBUTE_UNUSED, float f13 ATTRIBUTE_UNUSED, float f14 ATTRIBUTE_UNUSED, float f15 ATTRIBUTE_UNUSED)
  72 {
  73   /* Check register contents.  */
  74   check_float_arguments;
  75 }
  76
  77 void
  78 fun_check_float_passing_float20_values (float f0 ATTRIBUTE_UNUSED, float f1 ATTRIBUTE_UNUSED, float f2 ATTRIBUTE_UNUSED, float f3 ATTRIBUTE_UNUSED, float f4 ATTRIBUTE_UNUSED, float f5 ATTRIBUTE_UNUSED, float f6 ATTRIBUTE_UNUSED, float f7 ATTRIBUTE_UNUSED, float f8 ATTRIBUTE_UNUSED, float f9 ATTRIBUTE_UNUSED, float f10 ATTRIBUTE_UNUSED, float f11 ATTRIBUTE_UNUSED, float f12 ATTRIBUTE_UNUSED, float f13 ATTRIBUTE_UNUSED, float f14 ATTRIBUTE_UNUSED, float f15 ATTRIBUTE_UNUSED, float f16 ATTRIBUTE_UNUSED, float f17 ATTRIBUTE_UNUSED, float f18 ATTRIBUTE_UNUSED, float f19 ATTRIBUTE_UNUSED)
  79 {
  80   /* Check argument values.  */
  81   assert (values_float.f0 == f0);
  82   assert (values_float.f1 == f1);
  83   assert (values_float.f2 == f2);
  84   assert (values_float.f3 == f3);
  85   assert (values_float.f4 == f4);
  86   assert (values_float.f5 == f5);
  87   assert (values_float.f6 == f6);
  88   assert (values_float.f7 == f7);
  89   assert (values_float.f8 == f8);
  90   assert (values_float.f9 == f9);
  91   assert (values_float.f10 == f10);
  92   assert (values_float.f11 == f11);
  93   assert (values_float.f12 == f12);
  94   assert (values_float.f13 == f13);
  95   assert (values_float.f14 == f14);
  96   assert (values_float.f15 == f15);
  97   assert (values_float.f16 == f16);
  98   assert (values_float.f17 == f17);
  99   assert (values_float.f18 == f18);
 100   assert (values_float.f19 == f19);
 101
 102 }
 103
 104 void
 105 fun_check_float_passing_float20_regs (float f0 ATTRIBUTE_UNUSED, float f1 ATTRIBUTE_UNUSED, float f2 ATTRIBUTE_UNUSED, float f3 ATTRIBUTE_UNUSED, float f4 ATTRIBUTE_UNUSED, float f5 ATTRIBUTE_UNUSED, float f6 ATTRIBUTE_UNUSED, float f7 ATTRIBUTE_UNUSED, float f8 ATTRIBUTE_UNUSED, float f9 ATTRIBUTE_UNUSED, float f10 ATTRIBUTE_UNUSED, float f11 ATTRIBUTE_UNUSED, float f12 ATTRIBUTE_UNUSED, float f13 ATTRIBUTE_UNUSED, float f14 ATTRIBUTE_UNUSED, float f15 ATTRIBUTE_UNUSED, float f16 ATTRIBUTE_UNUSED, float f17 ATTRIBUTE_UNUSED, float f18 ATTRIBUTE_UNUSED, float f19 ATTRIBUTE_UNUSED)
 106 {
 107   /* Check register contents.  */
 108   check_float_arguments;
 109 }
 110
 111 void
 112 fun_check_float_passing_double8_values (double f0 ATTRIBUTE_UNUSED, double f1 ATTRIBUTE_UNUSED, double f2 ATTRIBUTE_UNUSED, double f3 ATTRIBUTE_UNUSED, double f4 ATTRIBUTE_UNUSED, double f5 ATTRIBUTE_UNUSED, double f6 ATTRIBUTE_UNUSED, double f7 ATTRIBUTE_UNUSED)
 113 {
 114   /* Check argument values.  */
 115   assert (values_double.f0 == f0);
 116   assert (values_double.f1 == f1);
 117   assert (values_double.f2 == f2);
 118   assert (values_double.f3 == f3);
 119   assert (values_double.f4 == f4);
 120   assert (values_double.f5 == f5);
 121   assert (values_double.f6 == f6);
 122   assert (values_double.f7 == f7);
 123
 124 }
 125
 126 void
 127 fun_check_float_passing_double8_regs (double f0 ATTRIBUTE_UNUSED, double f1 ATTRIBUTE_UNUSED, double f2 ATTRIBUTE_UNUSED, double f3 ATTRIBUTE_UNUSED, double f4 ATTRIBUTE_UNUSED, double f5 ATTRIBUTE_UNUSED, double f6 ATTRIBUTE_UNUSED, double f7 ATTRIBUTE_UNUSED)
 128 {
 129   /* Check register contents.  */
 130   check_double_arguments;
 131 }
 132
 133 void
 134 fun_check_float_passing_double16_values (double f0 ATTRIBUTE_UNUSED, double f1 ATTRIBUTE_UNUSED, double f2 ATTRIBUTE_UNUSED, double f3 ATTRIBUTE_UNUSED, double f4 ATTRIBUTE_UNUSED, double f5 ATTRIBUTE_UNUSED, double f6 ATTRIBUTE_UNUSED, double f7 ATTRIBUTE_UNUSED, double f8 ATTRIBUTE_UNUSED, double f9 ATTRIBUTE_UNUSED, double f10 ATTRIBUTE_UNUSED, double f11 ATTRIBUTE_UNUSED, double f12 ATTRIBUTE_UNUSED, double f13 ATTRIBUTE_UNUSED, double f14 ATTRIBUTE_UNUSED, double f15 ATTRIBUTE_UNUSED)
 135 {
 136   /* Check argument values.  */
 137   assert (values_double.f0 == f0);
 138   assert (values_double.f1 == f1);
 139   assert (values_double.f2 == f2);
 140   assert (values_double.f3 == f3);
 141   assert (values_double.f4 == f4);
 142   assert (values_double.f5 == f5);
 143   assert (values_double.f6 == f6);
 144   assert (values_double.f7 == f7);
 145   assert (values_double.f8 == f8);
 146   assert (values_double.f9 == f9);
 147   assert (values_double.f10 == f10);
 148   assert (values_double.f11 == f11);
 149   assert (values_double.f12 == f12);
 150   assert (values_double.f13 == f13);
 151   assert (values_double.f14 == f14);
 152   assert (values_double.f15 == f15);
 153
 154 }
 155
 156 void
 157 fun_check_float_passing_double16_regs (double f0 ATTRIBUTE_UNUSED, double f1 ATTRIBUTE_UNUSED, double f2 ATTRIBUTE_UNUSED, double f3 ATTRIBUTE_UNUSED, double f4 ATTRIBUTE_UNUSED, double f5 ATTRIBUTE_UNUSED, double f6 ATTRIBUTE_UNUSED, double f7 ATTRIBUTE_UNUSED, double f8 ATTRIBUTE_UNUSED, double f9 ATTRIBUTE_UNUSED, double f10 ATTRIBUTE_UNUSED, double f11 ATTRIBUTE_UNUSED, double f12 ATTRIBUTE_UNUSED, double f13 ATTRIBUTE_UNUSED, double f14 ATTRIBUTE_UNUSED, double f15 ATTRIBUTE_UNUSED)
 158 {
 159   /* Check register contents.  */
 160   check_double_arguments;
 161 }
 162
 163 void
 164 fun_check_float_passing_double20_values (double f0 ATTRIBUTE_UNUSED, double f1 ATTRIBUTE_UNUSED, double f2 ATTRIBUTE_UNUSED, double f3 ATTRIBUTE_UNUSED, double f4 ATTRIBUTE_UNUSED, double f5 ATTRIBUTE_UNUSED, double f6 ATTRIBUTE_UNUSED, double f7 ATTRIBUTE_UNUSED, double f8 ATTRIBUTE_UNUSED, double f9 ATTRIBUTE_UNUSED, double f10 ATTRIBUTE_UNUSED, double f11 ATTRIBUTE_UNUSED, double f12 ATTRIBUTE_UNUSED, double f13 ATTRIBUTE_UNUSED, double f14 ATTRIBUTE_UNUSED, double f15 ATTRIBUTE_UNUSED, double f16 ATTRIBUTE_UNUSED, double f17 ATTRIBUTE_UNUSED, double f18 ATTRIBUTE_UNUSED, double f19 ATTRIBUTE_UNUSED)
 165 {
 166   /* Check argument values.  */
 167   assert (values_double.f0 == f0);
 168   assert (values_double.f1 == f1);
 169   assert (values_double.f2 == f2);
 170   assert (values_double.f3 == f3);
 171   assert (values_double.f4 == f4);
 172   assert (values_double.f5 == f5);
 173   assert (values_double.f6 == f6);
 174   assert (values_double.f7 == f7);
 175   assert (values_double.f8 == f8);
 176   assert (values_double.f9 == f9);
 177   assert (values_double.f10 == f10);
 178   assert (values_double.f11 == f11);
 179   assert (values_double.f12 == f12);
 180   assert (values_double.f13 == f13);
 181   assert (values_double.f14 == f14);
 182   assert (values_double.f15 == f15);
 183   assert (values_double.f16 == f16);
 184   assert (values_double.f17 == f17);
 185   assert (values_double.f18 == f18);
 186   assert (values_double.f19 == f19);
 187
 188 }
 189
 190 void
 191 fun_check_float_passing_double20_regs (double f0 ATTRIBUTE_UNUSED, double f1 ATTRIBUTE_UNUSED, double f2 ATTRIBUTE_UNUSED, double f3 ATTRIBUTE_UNUSED, double f4 ATTRIBUTE_UNUSED, double f5 ATTRIBUTE_UNUSED, double f6 ATTRIBUTE_UNUSED, double f7 ATTRIBUTE_UNUSED, double f8 ATTRIBUTE_UNUSED, double f9 ATTRIBUTE_UNUSED, double f10 ATTRIBUTE_UNUSED, double f11 ATTRIBUTE_UNUSED, double f12 ATTRIBUTE_UNUSED, double f13 ATTRIBUTE_UNUSED, double f14 ATTRIBUTE_UNUSED, double f15 ATTRIBUTE_UNUSED, double f16 ATTRIBUTE_UNUSED, double f17 ATTRIBUTE_UNUSED, double f18 ATTRIBUTE_UNUSED, double f19 ATTRIBUTE_UNUSED)
 192 {
 193   /* Check register contents.  */
 194   check_double_arguments;
 195 }
 196
 197 void
 198 fun_check_x87_passing_ldouble8_values (ldouble f0 ATTRIBUTE_UNUSED, ldouble f1 ATTRIBUTE_UNUSED, ldouble f2 ATTRIBUTE_UNUSED, ldouble f3 ATTRIBUTE_UNUSED, ldouble f4 ATTRIBUTE_UNUSED, ldouble f5 ATTRIBUTE_UNUSED, ldouble f6 ATTRIBUTE_UNUSED, ldouble f7 ATTRIBUTE_UNUSED)
 199 {
 200   /* Check argument values.  */
 201   assert (values_ldouble.f0 == f0);
 202   assert (values_ldouble.f1 == f1);
 203   assert (values_ldouble.f2 == f2);
 204   assert (values_ldouble.f3 == f3);
 205   assert (values_ldouble.f4 == f4);
 206   assert (values_ldouble.f5 == f5);
 207   assert (values_ldouble.f6 == f6);
 208   assert (values_ldouble.f7 == f7);
 209
 210 }
 211
 212 void
 213 fun_check_x87_passing_ldouble8_regs (ldouble f0 ATTRIBUTE_UNUSED, ldouble f1 ATTRIBUTE_UNUSED, ldouble f2 ATTRIBUTE_UNUSED, ldouble f3 ATTRIBUTE_UNUSED, ldouble f4 ATTRIBUTE_UNUSED, ldouble f5 ATTRIBUTE_UNUSED, ldouble f6 ATTRIBUTE_UNUSED, ldouble f7 ATTRIBUTE_UNUSED)
 214 {
 215   /* Check register contents.  */
 216   check_ldouble_arguments;
 217 }
 218
 219 void
 220 fun_check_x87_passing_ldouble16_values (ldouble f0 ATTRIBUTE_UNUSED, ldouble f1 ATTRIBUTE_UNUSED, ldouble f2 ATTRIBUTE_UNUSED, ldouble f3 ATTRIBUTE_UNUSED, ldouble f4 ATTRIBUTE_UNUSED, ldouble f5 ATTRIBUTE_UNUSED, ldouble f6 ATTRIBUTE_UNUSED, ldouble f7 ATTRIBUTE_UNUSED, ldouble f8 ATTRIBUTE_UNUSED, ldouble f9 ATTRIBUTE_UNUSED, ldouble f10 ATTRIBUTE_UNUSED, ldouble f11 ATTRIBUTE_UNUSED, ldouble f12 ATTRIBUTE_UNUSED, ldouble f13 ATTRIBUTE_UNUSED, ldouble f14 ATTRIBUTE_UNUSED, ldouble f15 ATTRIBUTE_UNUSED)
 221 {
 222   /* Check argument values.  */
 223   assert (values_ldouble.f0 == f0);
 224   assert (values_ldouble.f1 == f1);
 225   assert (values_ldouble.f2 == f2);
 226   assert (values_ldouble.f3 == f3);
 227   assert (values_ldouble.f4 == f4);
 228   assert (values_ldouble.f5 == f5);
 229   assert (values_ldouble.f6 == f6);
 230   assert (values_ldouble.f7 == f7);
 231   assert (values_ldouble.f8 == f8);
 232   assert (values_ldouble.f9 == f9);
 233   assert (values_ldouble.f10 == f10);
 234   assert (values_ldouble.f11 == f11);
 235   assert (values_ldouble.f12 == f12);
 236   assert (values_ldouble.f13 == f13);
 237   assert (values_ldouble.f14 == f14);
 238   assert (values_ldouble.f15 == f15);
 239
 240 }
 241
 242 void
 243 fun_check_x87_passing_ldouble16_regs (ldouble f0 ATTRIBUTE_UNUSED, ldouble f1 ATTRIBUTE_UNUSED, ldouble f2 ATTRIBUTE_UNUSED, ldouble f3 ATTRIBUTE_UNUSED, ldouble f4 ATTRIBUTE_UNUSED, ldouble f5 ATTRIBUTE_UNUSED, ldouble f6 ATTRIBUTE_UNUSED, ldouble f7 ATTRIBUTE_UNUSED, ldouble f8 ATTRIBUTE_UNUSED, ldouble f9 ATTRIBUTE_UNUSED, ldouble f10 ATTRIBUTE_UNUSED, ldouble f11 ATTRIBUTE_UNUSED, ldouble f12 ATTRIBUTE_UNUSED, ldouble f13 ATTRIBUTE_UNUSED, ldouble f14 ATTRIBUTE_UNUSED, ldouble f15 ATTRIBUTE_UNUSED)
 244 {
 245   /* Check register contents.  */
 246   check_ldouble_arguments;
 247 }
 248
 249 void
 250 fun_check_x87_passing_ldouble20_values (ldouble f0 ATTRIBUTE_UNUSED, ldouble f1 ATTRIBUTE_UNUSED, ldouble f2 ATTRIBUTE_UNUSED, ldouble f3 ATTRIBUTE_UNUSED, ldouble f4 ATTRIBUTE_UNUSED, ldouble f5 ATTRIBUTE_UNUSED, ldouble f6 ATTRIBUTE_UNUSED, ldouble f7 ATTRIBUTE_UNUSED, ldouble f8 ATTRIBUTE_UNUSED, ldouble f9 ATTRIBUTE_UNUSED, ldouble f10 ATTRIBUTE_UNUSED, ldouble f11 ATTRIBUTE_UNUSED, ldouble f12 ATTRIBUTE_UNUSED, ldouble f13 ATTRIBUTE_UNUSED, ldouble f14 ATTRIBUTE_UNUSED, ldouble f15 ATTRIBUTE_UNUSED, ldouble f16 ATTRIBUTE_UNUSED, ldouble f17 ATTRIBUTE_UNUSED, ldouble f18 ATTRIBUTE_UNUSED, ldouble f19 ATTRIBUTE_UNUSED)
 251 {
 252   /* Check argument values.  */
 253   assert (values_ldouble.f0 == f0);
 254   assert (values_ldouble.f1 == f1);
 255   assert (values_ldouble.f2 == f2);
 256   assert (values_ldouble.f3 == f3);
 257   assert (values_ldouble.f4 == f4);
 258   assert (values_ldouble.f5 == f5);
 259   assert (values_ldouble.f6 == f6);
 260   assert (values_ldouble.f7 == f7);
 261   assert (values_ldouble.f8 == f8);
 262   assert (values_ldouble.f9 == f9);
 263   assert (values_ldouble.f10 == f10);
 264   assert (values_ldouble.f11 == f11);
 265   assert (values_ldouble.f12 == f12);
 266   assert (values_ldouble.f13 == f13);
 267   assert (values_ldouble.f14 == f14);
 268   assert (values_ldouble.f15 == f15);
 269   assert (values_ldouble.f16 == f16);
 270   assert (values_ldouble.f17 == f17);
 271   assert (values_ldouble.f18 == f18);
 272   assert (values_ldouble.f19 == f19);
 273
 274 }
 275
 276 void
 277 fun_check_x87_passing_ldouble20_regs (ldouble f0 ATTRIBUTE_UNUSED, ldouble f1 ATTRIBUTE_UNUSED, ldouble f2 ATTRIBUTE_UNUSED, ldouble f3 ATTRIBUTE_UNUSED, ldouble f4 ATTRIBUTE_UNUSED, ldouble f5 ATTRIBUTE_UNUSED, ldouble f6 ATTRIBUTE_UNUSED, ldouble f7 ATTRIBUTE_UNUSED, ldouble f8 ATTRIBUTE_UNUSED, ldouble f9 ATTRIBUTE_UNUSED, ldouble f10 ATTRIBUTE_UNUSED, ldouble f11 ATTRIBUTE_UNUSED, ldouble f12 ATTRIBUTE_UNUSED, ldouble f13 ATTRIBUTE_UNUSED, ldouble f14 ATTRIBUTE_UNUSED, ldouble f15 ATTRIBUTE_UNUSED, ldouble f16 ATTRIBUTE_UNUSED, ldouble f17 ATTRIBUTE_UNUSED, ldouble f18 ATTRIBUTE_UNUSED, ldouble f19 ATTRIBUTE_UNUSED)
 278 {
 279   /* Check register contents.  */
 280   check_ldouble_arguments;
 281 }
 282
 283 #define def_check_float_passing8(_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _func1, _func2, TYPE) \
 284   values_ ## TYPE .f0 = _f0; \
 285   values_ ## TYPE .f1 = _f1; \
 286   values_ ## TYPE .f2 = _f2; \
 287   values_ ## TYPE .f3 = _f3; \
 288   values_ ## TYPE .f4 = _f4; \
 289   values_ ## TYPE .f5 = _f5; \
 290   values_ ## TYPE .f6 = _f6; \
 291   values_ ## TYPE .f7 = _f7; \
 292   WRAP_CALL(_func1) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7); \
 293   \
 294   clear_int_registers; \
 295   if (sizeof (TYPE) == 4) \
 296     { \
 297       u.f = _f0; \
 298       iregs.I0 = u.i[0]; \
 299       u.f = _f1; \
 300       iregs.I1 = u.i[0]; \
 301       u.f = _f2; \
 302       iregs.I2 = u.i[0]; \
 303       num_iregs = 3; \
 304     } \
 305   else \
 306     { \
 307       u.d = _f0; \
 308       iregs.I0 = u.i[0]; \
 309       iregs.I1 = u.i[1]; \
 310       num_iregs = 2; \
 311     } \
 312   WRAP_CALL(_func2) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7);
 313
 314 #define def_check_float_passing16(_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15, _func1, _func2, TYPE) \
 315   values_ ## TYPE .f0 = _f0; \
 316   values_ ## TYPE .f1 = _f1; \
 317   values_ ## TYPE .f2 = _f2; \
 318   values_ ## TYPE .f3 = _f3; \
 319   values_ ## TYPE .f4 = _f4; \
 320   values_ ## TYPE .f5 = _f5; \
 321   values_ ## TYPE .f6 = _f6; \
 322   values_ ## TYPE .f7 = _f7; \
 323   values_ ## TYPE .f8 = _f8; \
 324   values_ ## TYPE .f9 = _f9; \
 325   values_ ## TYPE .f10 = _f10; \
 326   values_ ## TYPE .f11 = _f11; \
 327   values_ ## TYPE .f12 = _f12; \
 328   values_ ## TYPE .f13 = _f13; \
 329   values_ ## TYPE .f14 = _f14; \
 330   values_ ## TYPE .f15 = _f15; \
 331   WRAP_CALL(_func1) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15); \
 332   \
 333   clear_int_registers; \
 334   if (sizeof (TYPE) == 4) \
 335     { \
 336       u.f = _f0; \
 337       iregs.I0 = u.i[0]; \
 338       u.f = _f1; \
 339       iregs.I1 = u.i[0]; \
 340       u.f = _f2; \
 341       iregs.I2 = u.i[0]; \
 342       num_iregs = 3; \
 343     } \
 344   else \
 345     { \
 346       u.d = _f0; \
 347       iregs.I0 = u.i[0]; \
 348       iregs.I1 = u.i[1]; \
 349       num_iregs = 2; \
 350     } \
 351   WRAP_CALL(_func2) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15);
 352
 353 #define def_check_float_passing20(_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15, _f16, _f17, _f18, _f19, _func1, _func2, TYPE) \
 354   values_ ## TYPE .f0 = _f0; \
 355   values_ ## TYPE .f1 = _f1; \
 356   values_ ## TYPE .f2 = _f2; \
 357   values_ ## TYPE .f3 = _f3; \
 358   values_ ## TYPE .f4 = _f4; \
 359   values_ ## TYPE .f5 = _f5; \
 360   values_ ## TYPE .f6 = _f6; \
 361   values_ ## TYPE .f7 = _f7; \
 362   values_ ## TYPE .f8 = _f8; \
 363   values_ ## TYPE .f9 = _f9; \
 364   values_ ## TYPE .f10 = _f10; \
 365   values_ ## TYPE .f11 = _f11; \
 366   values_ ## TYPE .f12 = _f12; \
 367   values_ ## TYPE .f13 = _f13; \
 368   values_ ## TYPE .f14 = _f14; \
 369   values_ ## TYPE .f15 = _f15; \
 370   values_ ## TYPE .f16 = _f16; \
 371   values_ ## TYPE .f17 = _f17; \
 372   values_ ## TYPE .f18 = _f18; \
 373   values_ ## TYPE .f19 = _f19; \
 374   WRAP_CALL(_func1) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15, _f16, _f17, _f18, _f19); \
 375   \
 376   clear_int_registers; \
 377   if (sizeof (TYPE) == 4) \
 378     { \
 379       u.f = _f0; \
 380       iregs.I0 = u.i[0]; \
 381       u.f = _f1; \
 382       iregs.I1 = u.i[0]; \
 383       u.f = _f2; \
 384       iregs.I2 = u.i[0]; \
 385       num_iregs = 3; \
 386     } \
 387   else \
 388     { \
 389       u.d = _f0; \
 390       iregs.I0 = u.i[0]; \
 391       iregs.I1 = u.i[1]; \
 392       num_iregs = 2; \
 393     } \
 394   WRAP_CALL(_func2) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15, _f16, _f17, _f18, _f19);
 395
 396 #define def_check_x87_passing8(_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _func1, _func2, TYPE) \
 397   values_ ## TYPE .f0 = _f0; \
 398   values_ ## TYPE .f1 = _f1; \
 399   values_ ## TYPE .f2 = _f2; \
 400   values_ ## TYPE .f3 = _f3; \
 401   values_ ## TYPE .f4 = _f4; \
 402   values_ ## TYPE .f5 = _f5; \
 403   values_ ## TYPE .f6 = _f6; \
 404   values_ ## TYPE .f7 = _f7; \
 405   WRAP_CALL(_func1) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7); \
 406   \
 407   clear_int_registers; \
 408   if (sizeof (TYPE) == 4) \
 409     { \
 410       u.f = _f0; \
 411       iregs.I0 = u.i[0]; \
 412       u.f = _f1; \
 413       iregs.I1 = u.i[0]; \
 414       u.f = _f2; \
 415       iregs.I2 = u.i[0]; \
 416       num_iregs = 3; \
 417     } \
 418   else \
 419     { \
 420       u.d = _f0; \
 421       iregs.I0 = u.i[0]; \
 422       iregs.I1 = u.i[1]; \
 423       num_iregs = 2; \
 424     } \
 425   WRAP_CALL(_func2) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7);
 426
 427 #define def_check_x87_passing16(_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15, _func1, _func2, TYPE) \
 428   values_ ## TYPE .f0 = _f0; \
 429   values_ ## TYPE .f1 = _f1; \
 430   values_ ## TYPE .f2 = _f2; \
 431   values_ ## TYPE .f3 = _f3; \
 432   values_ ## TYPE .f4 = _f4; \
 433   values_ ## TYPE .f5 = _f5; \
 434   values_ ## TYPE .f6 = _f6; \
 435   values_ ## TYPE .f7 = _f7; \
 436   values_ ## TYPE .f8 = _f8; \
 437   values_ ## TYPE .f9 = _f9; \
 438   values_ ## TYPE .f10 = _f10; \
 439   values_ ## TYPE .f11 = _f11; \
 440   values_ ## TYPE .f12 = _f12; \
 441   values_ ## TYPE .f13 = _f13; \
 442   values_ ## TYPE .f14 = _f14; \
 443   values_ ## TYPE .f15 = _f15; \
 444   WRAP_CALL(_func1) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15); \
 445   \
 446   clear_int_registers; \
 447   if (sizeof (TYPE) == 4) \
 448     { \
 449       u.f = _f0; \
 450       iregs.I0 = u.i[0]; \
 451       u.f = _f1; \
 452       iregs.I1 = u.i[0]; \
 453       u.f = _f2; \
 454       iregs.I2 = u.i[0]; \
 455       num_iregs = 3; \
 456     } \
 457   else \
 458     { \
 459       u.d = _f0; \
 460       iregs.I0 = u.i[0]; \
 461       iregs.I1 = u.i[1]; \
 462       num_iregs = 2; \
 463     } \
 464   WRAP_CALL(_func2) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15);
 465
 466 #define def_check_x87_passing20(_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15, _f16, _f17, _f18, _f19, _func1, _func2, TYPE) \
 467   values_ ## TYPE .f0 = _f0; \
 468   values_ ## TYPE .f1 = _f1; \
 469   values_ ## TYPE .f2 = _f2; \
 470   values_ ## TYPE .f3 = _f3; \
 471   values_ ## TYPE .f4 = _f4; \
 472   values_ ## TYPE .f5 = _f5; \
 473   values_ ## TYPE .f6 = _f6; \
 474   values_ ## TYPE .f7 = _f7; \
 475   values_ ## TYPE .f8 = _f8; \
 476   values_ ## TYPE .f9 = _f9; \
 477   values_ ## TYPE .f10 = _f10; \
 478   values_ ## TYPE .f11 = _f11; \
 479   values_ ## TYPE .f12 = _f12; \
 480   values_ ## TYPE .f13 = _f13; \
 481   values_ ## TYPE .f14 = _f14; \
 482   values_ ## TYPE .f15 = _f15; \
 483   values_ ## TYPE .f16 = _f16; \
 484   values_ ## TYPE .f17 = _f17; \
 485   values_ ## TYPE .f18 = _f18; \
 486   values_ ## TYPE .f19 = _f19; \
 487   WRAP_CALL(_func1) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15, _f16, _f17, _f18, _f19); \
 488   \
 489   clear_int_registers; \
 490   if (sizeof (TYPE) == 4) \
 491     { \
 492       u.f = _f0; \
 493       iregs.I0 = u.i[0]; \
 494       u.f = _f1; \
 495       iregs.I1 = u.i[0]; \
 496       u.f = _f2; \
 497       iregs.I2 = u.i[0]; \
 498       num_iregs = 3; \
 499     } \
 500   else \
 501     { \
 502       u.d = _f0; \
 503       iregs.I0 = u.i[0]; \
 504       iregs.I1 = u.i[1]; \
 505       num_iregs = 2; \
 506     } \
 507   WRAP_CALL(_func2) (_f0, _f1, _f2, _f3, _f4, _f5, _f6, _f7, _f8, _f9, _f10, _f11, _f12, _f13, _f14, _f15, _f16, _f17, _f18, _f19);
 508
 509 void
 510 test_floats_on_stack ()
 511 {
 512   union
 513     {
 514       float f;
 515       double d;
 516       int i[2];
 517     } u;
 518   def_check_float_passing8(32, 33, 34, 35, 36, 37, 38, 39, fun_check_float_passing_float8_values, fun_check_float_passing_float8_regs, float);
 519
 520   def_check_float_passing16(32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, fun_check_float_passing_float16_values, fun_check_float_passing_float16_regs, float);
 521 }
 522
 523 void
 524 test_too_many_floats ()
 525 {
 526   union
 527     {
 528       float f;
 529       double d;
 530       int i[2];
 531     } u;
 532   def_check_float_passing20(32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, fun_check_float_passing_float20_values, fun_check_float_passing_float20_regs, float);
 533 }
 534
 535 void
 536 test_doubles_on_stack ()
 537 {
 538   union
 539     {
 540       float f;
 541       double d;
 542       int i[2];
 543     } u;
 544   def_check_float_passing8(32, 33, 34, 35, 36, 37, 38, 39, fun_check_float_passing_double8_values, fun_check_float_passing_double8_regs, double);
 545
 546   def_check_float_passing16(32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, fun_check_float_passing_double16_values, fun_check_float_passing_double16_regs, double);
 547 }
 548
 549 void
 550 test_too_many_doubles ()
 551 {
 552   union
 553     {
 554       float f;
 555       double d;
 556       int i[2];
 557     } u;
 558   def_check_float_passing20(32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, fun_check_float_passing_double20_values, fun_check_float_passing_double20_regs, double);
 559 }
 560
 561 void
 562 test_long_doubles_on_stack ()
 563 {
 564   union
 565     {
 566       float f;
 567       double d;
 568       int i[2];
 569     } u;
 570   def_check_x87_passing8(32, 33, 34, 35, 36, 37, 38, 39, fun_check_x87_passing_ldouble8_values, fun_check_x87_passing_ldouble8_regs, ldouble);
 571 }
 572
 573 void
 574 test_too_many_long_doubles ()
 575 {
 576   union
 577     {
 578       float f;
 579       double d;
 580       int i[2];
 581     } u;
 582   def_check_x87_passing20(32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, fun_check_x87_passing_ldouble20_values, fun_check_x87_passing_ldouble20_regs, ldouble);
 583 }
 584
 585 void
 586 test_float128s_on_stack ()
 587 {
 588 }
 589
 590 void
 591 test_too_many_float128s ()
 592 {
 593 }
 594
 595
 596 int
 597 main (void)
 598 {
 599   test_floats_on_stack ();
 600   test_too_many_floats ();
 601   test_doubles_on_stack ();
 602   test_too_many_doubles ();
 603   test_long_doubles_on_stack ();
 604   test_too_many_long_doubles ();
 605   test_float128s_on_stack ();
 606   test_too_many_float128s ();
 607   return 0;
 608 }