gcc/testsuite/gcc.target/x86_64/abi/avx512fp16/m256h/test_passing_m256.c

   1 #include <stdio.h>
   2 #include "avx512fp16-ymm-check.h"
   3 #include "args.h"
   4
   5 struct IntegerRegisters iregs;
   6 struct FloatRegisters fregs;
   7 unsigned int num_iregs, num_fregs;
   8
   9 /* This struct holds values for argument checking.  */
  10 struct
  11 {
  12   YMM_T i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15,
  13     i16, i17, i18, i19, i20, i21, i22, i23;
  14 } values;
  15
  16 char *pass;
  17 int failed = 0;
  18
  19 #undef assert
  20 #define assert(c) do { \
  21   if (!(c)) {failed++; printf ("failed %s\n", pass); } \
  22 } while (0)
  23
  24 #define compare(X1,X2,T) do { \
  25   assert (memcmp (&X1, &X2, sizeof (T)) == 0); \
  26 } while (0)
  27
  28 void
  29 fun_check_passing_m256_8_values (__m256 i0 ATTRIBUTE_UNUSED,
  30                                  __m256 i1 ATTRIBUTE_UNUSED,
  31                                  __m256 i2 ATTRIBUTE_UNUSED,
  32                                  __m256 i3 ATTRIBUTE_UNUSED,
  33                                  __m256 i4 ATTRIBUTE_UNUSED,
  34                                  __m256 i5 ATTRIBUTE_UNUSED,
  35                                  __m256 i6 ATTRIBUTE_UNUSED,
  36                                  __m256 i7 ATTRIBUTE_UNUSED)
  37 {
  38   /* Check argument values.  */
  39   compare (values.i0, i0, __m256);
  40   compare (values.i1, i1, __m256);
  41   compare (values.i2, i2, __m256);
  42   compare (values.i3, i3, __m256);
  43   compare (values.i4, i4, __m256);
  44   compare (values.i5, i5, __m256);
  45   compare (values.i6, i6, __m256);
  46   compare (values.i7, i7, __m256);
  47 }
  48
  49 void
  50 fun_check_passing_m256h_8_values (__m256h i0 ATTRIBUTE_UNUSED,
  51                                   __m256h i1 ATTRIBUTE_UNUSED,
  52                                   __m256h i2 ATTRIBUTE_UNUSED,
  53                                   __m256h i3 ATTRIBUTE_UNUSED,
  54                                   __m256h i4 ATTRIBUTE_UNUSED,
  55                                   __m256h i5 ATTRIBUTE_UNUSED,
  56                                   __m256h i6 ATTRIBUTE_UNUSED,
  57                                   __m256h i7 ATTRIBUTE_UNUSED)
  58 {
  59   /* Check argument values.  */
  60   compare (values.i0, i0, __m256h);
  61   compare (values.i1, i1, __m256h);
  62   compare (values.i2, i2, __m256h);
  63   compare (values.i3, i3, __m256h);
  64   compare (values.i4, i4, __m256h);
  65   compare (values.i5, i5, __m256h);
  66   compare (values.i6, i6, __m256h);
  67   compare (values.i7, i7, __m256h);
  68 }
  69
  70 void
  71 fun_check_passing_m256_8_regs (__m256 i0 ATTRIBUTE_UNUSED,
  72                                __m256 i1 ATTRIBUTE_UNUSED,
  73                                __m256 i2 ATTRIBUTE_UNUSED,
  74                                __m256 i3 ATTRIBUTE_UNUSED,
  75                                __m256 i4 ATTRIBUTE_UNUSED,
  76                                __m256 i5 ATTRIBUTE_UNUSED,
  77                                __m256 i6 ATTRIBUTE_UNUSED,
  78                                __m256 i7 ATTRIBUTE_UNUSED)
  79 {
  80   /* Check register contents.  */
  81   check_m256_arguments;
  82 }
  83
  84 void
  85 fun_check_passing_m256h_8_regs (__m256h i0 ATTRIBUTE_UNUSED,
  86                                 __m256h i1 ATTRIBUTE_UNUSED,
  87                                 __m256h i2 ATTRIBUTE_UNUSED,
  88                                 __m256h i3 ATTRIBUTE_UNUSED,
  89                                 __m256h i4 ATTRIBUTE_UNUSED,
  90                                 __m256h i5 ATTRIBUTE_UNUSED,
  91                                 __m256h i6 ATTRIBUTE_UNUSED,
  92                                 __m256h i7 ATTRIBUTE_UNUSED)
  93 {
  94   /* Check register contents.  */
  95   check_m256_arguments;
  96 }
  97
  98 void
  99 fun_check_passing_m256_20_values (__m256 i0 ATTRIBUTE_UNUSED,
 100                                   __m256 i1 ATTRIBUTE_UNUSED,
 101                                   __m256 i2 ATTRIBUTE_UNUSED,
 102                                   __m256 i3 ATTRIBUTE_UNUSED,
 103                                   __m256 i4 ATTRIBUTE_UNUSED,
 104                                   __m256 i5 ATTRIBUTE_UNUSED,
 105                                   __m256 i6 ATTRIBUTE_UNUSED,
 106                                   __m256 i7 ATTRIBUTE_UNUSED,
 107                                   __m256 i8 ATTRIBUTE_UNUSED,
 108                                   __m256 i9 ATTRIBUTE_UNUSED,
 109                                   __m256 i10 ATTRIBUTE_UNUSED,
 110                                   __m256 i11 ATTRIBUTE_UNUSED,
 111                                   __m256 i12 ATTRIBUTE_UNUSED,
 112                                   __m256 i13 ATTRIBUTE_UNUSED,
 113                                   __m256 i14 ATTRIBUTE_UNUSED,
 114                                   __m256 i15 ATTRIBUTE_UNUSED,
 115                                   __m256 i16 ATTRIBUTE_UNUSED,
 116                                   __m256 i17 ATTRIBUTE_UNUSED,
 117                                   __m256 i18 ATTRIBUTE_UNUSED,
 118                                   __m256 i19 ATTRIBUTE_UNUSED)
 119 {
 120   /* Check argument values.  */
 121   compare (values.i0, i0, __m256);
 122   compare (values.i1, i1, __m256);
 123   compare (values.i2, i2, __m256);
 124   compare (values.i3, i3, __m256);
 125   compare (values.i4, i4, __m256);
 126   compare (values.i5, i5, __m256);
 127   compare (values.i6, i6, __m256);
 128   compare (values.i7, i7, __m256);
 129   compare (values.i8, i8, __m256);
 130   compare (values.i9, i9, __m256);
 131   compare (values.i10, i10, __m256);
 132   compare (values.i11, i11, __m256);
 133   compare (values.i12, i12, __m256);
 134   compare (values.i13, i13, __m256);
 135   compare (values.i14, i14, __m256);
 136   compare (values.i15, i15, __m256);
 137   compare (values.i16, i16, __m256);
 138   compare (values.i17, i17, __m256);
 139   compare (values.i18, i18, __m256);
 140   compare (values.i19, i19, __m256);
 141 }
 142
 143 void
 144 fun_check_passing_m256h_20_values (__m256h i0 ATTRIBUTE_UNUSED,
 145                                    __m256h i1 ATTRIBUTE_UNUSED,
 146                                    __m256h i2 ATTRIBUTE_UNUSED,
 147                                    __m256h i3 ATTRIBUTE_UNUSED,
 148                                    __m256h i4 ATTRIBUTE_UNUSED,
 149                                    __m256h i5 ATTRIBUTE_UNUSED,
 150                                    __m256h i6 ATTRIBUTE_UNUSED,
 151                                    __m256h i7 ATTRIBUTE_UNUSED,
 152                                    __m256h i8 ATTRIBUTE_UNUSED,
 153                                    __m256h i9 ATTRIBUTE_UNUSED,
 154                                    __m256h i10 ATTRIBUTE_UNUSED,
 155                                    __m256h i11 ATTRIBUTE_UNUSED,
 156                                    __m256h i12 ATTRIBUTE_UNUSED,
 157                                    __m256h i13 ATTRIBUTE_UNUSED,
 158                                    __m256h i14 ATTRIBUTE_UNUSED,
 159                                    __m256h i15 ATTRIBUTE_UNUSED,
 160                                    __m256h i16 ATTRIBUTE_UNUSED,
 161                                    __m256h i17 ATTRIBUTE_UNUSED,
 162                                    __m256h i18 ATTRIBUTE_UNUSED,
 163                                    __m256h i19 ATTRIBUTE_UNUSED)
 164 {
 165   /* Check argument values.  */
 166   compare (values.i0, i0, __m256h);
 167   compare (values.i1, i1, __m256h);
 168   compare (values.i2, i2, __m256h);
 169   compare (values.i3, i3, __m256h);
 170   compare (values.i4, i4, __m256h);
 171   compare (values.i5, i5, __m256h);
 172   compare (values.i6, i6, __m256h);
 173   compare (values.i7, i7, __m256h);
 174   compare (values.i8, i8, __m256h);
 175   compare (values.i9, i9, __m256h);
 176   compare (values.i10, i10, __m256h);
 177   compare (values.i11, i11, __m256h);
 178   compare (values.i12, i12, __m256h);
 179   compare (values.i13, i13, __m256h);
 180   compare (values.i14, i14, __m256h);
 181   compare (values.i15, i15, __m256h);
 182   compare (values.i16, i16, __m256h);
 183   compare (values.i17, i17, __m256h);
 184   compare (values.i18, i18, __m256h);
 185   compare (values.i19, i19, __m256h);
 186 }
 187
 188 void
 189 fun_check_passing_m256_20_regs (__m256 i0 ATTRIBUTE_UNUSED,
 190                                 __m256 i1 ATTRIBUTE_UNUSED,
 191                                 __m256 i2 ATTRIBUTE_UNUSED,
 192                                 __m256 i3 ATTRIBUTE_UNUSED,
 193                                 __m256 i4 ATTRIBUTE_UNUSED,
 194                                 __m256 i5 ATTRIBUTE_UNUSED,
 195                                 __m256 i6 ATTRIBUTE_UNUSED,
 196                                 __m256 i7 ATTRIBUTE_UNUSED,
 197                                 __m256 i8 ATTRIBUTE_UNUSED,
 198                                 __m256 i9 ATTRIBUTE_UNUSED,
 199                                 __m256 i10 ATTRIBUTE_UNUSED,
 200                                 __m256 i11 ATTRIBUTE_UNUSED,
 201                                 __m256 i12 ATTRIBUTE_UNUSED,
 202                                 __m256 i13 ATTRIBUTE_UNUSED,
 203                                 __m256 i14 ATTRIBUTE_UNUSED,
 204                                 __m256 i15 ATTRIBUTE_UNUSED,
 205                                 __m256 i16 ATTRIBUTE_UNUSED,
 206                                 __m256 i17 ATTRIBUTE_UNUSED,
 207                                 __m256 i18 ATTRIBUTE_UNUSED,
 208                                 __m256 i19 ATTRIBUTE_UNUSED)
 209 {
 210   /* Check register contents.  */
 211   check_m256_arguments;
 212 }
 213
 214 void
 215 fun_check_passing_m256h_20_regs (__m256h i0 ATTRIBUTE_UNUSED,
 216                                  __m256h i1 ATTRIBUTE_UNUSED,
 217                                  __m256h i2 ATTRIBUTE_UNUSED,
 218                                  __m256h i3 ATTRIBUTE_UNUSED,
 219                                  __m256h i4 ATTRIBUTE_UNUSED,
 220                                  __m256h i5 ATTRIBUTE_UNUSED,
 221                                  __m256h i6 ATTRIBUTE_UNUSED,
 222                                  __m256h i7 ATTRIBUTE_UNUSED,
 223                                  __m256h i8 ATTRIBUTE_UNUSED,
 224                                  __m256h i9 ATTRIBUTE_UNUSED,
 225                                  __m256h i10 ATTRIBUTE_UNUSED,
 226                                  __m256h i11 ATTRIBUTE_UNUSED,
 227                                  __m256h i12 ATTRIBUTE_UNUSED,
 228                                  __m256h i13 ATTRIBUTE_UNUSED,
 229                                  __m256h i14 ATTRIBUTE_UNUSED,
 230                                  __m256h i15 ATTRIBUTE_UNUSED,
 231                                  __m256h i16 ATTRIBUTE_UNUSED,
 232                                  __m256h i17 ATTRIBUTE_UNUSED,
 233                                  __m256h i18 ATTRIBUTE_UNUSED,
 234                                  __m256h i19 ATTRIBUTE_UNUSED)
 235 {
 236   /* Check register contents.  */
 237   check_m256_arguments;
 238 }
 239
 240 #define def_check_passing8(_i0, _i1, _i2, _i3, _i4, _i5, _i6, _i7, _func1, _func2, TYPE) \
 241   values.i0.TYPE[0] = _i0; \
 242   values.i1.TYPE[0] = _i1; \
 243   values.i2.TYPE[0] = _i2; \
 244   values.i3.TYPE[0] = _i3; \
 245   values.i4.TYPE[0] = _i4; \
 246   values.i5.TYPE[0] = _i5; \
 247   values.i6.TYPE[0] = _i6; \
 248   values.i7.TYPE[0] = _i7; \
 249   WRAP_CALL(_func1) (_i0, _i1, _i2, _i3, _i4, _i5, _i6, _i7); \
 250   clear_struct_registers; \
 251   fregs.F0.TYPE[0] = _i0; \
 252   fregs.F1.TYPE[0] = _i1; \
 253   fregs.F2.TYPE[0] = _i2; \
 254   fregs.F3.TYPE[0] = _i3; \
 255   fregs.F4.TYPE[0] = _i4; \
 256   fregs.F5.TYPE[0] = _i5; \
 257   fregs.F6.TYPE[0] = _i6; \
 258   fregs.F7.TYPE[0] = _i7; \
 259   num_fregs = 8; \
 260   WRAP_CALL(_func2) (_i0, _i1, _i2, _i3, _i4, _i5, _i6, _i7);
 261
 262 #define def_check_passing20(_i0, _i1, _i2, _i3, _i4, _i5, _i6, _i7, \
 263                             _i8, _i9, _i10, _i11, _i12, _i13, _i14, \
 264                             _i15, _i16, _i17, _i18, _i19, _func1, \
 265                             _func2, TYPE) \
 266   values.i0.TYPE[0] = _i0; \
 267   values.i1.TYPE[0] = _i1; \
 268   values.i2.TYPE[0] = _i2; \
 269   values.i3.TYPE[0] = _i3; \
 270   values.i4.TYPE[0] = _i4; \
 271   values.i5.TYPE[0] = _i5; \
 272   values.i6.TYPE[0] = _i6; \
 273   values.i7.TYPE[0] = _i7; \
 274   values.i8.TYPE[0] = _i8; \
 275   values.i9.TYPE[0] = _i9; \
 276   values.i10.TYPE[0] = _i10; \
 277   values.i11.TYPE[0] = _i11; \
 278   values.i12.TYPE[0] = _i12; \
 279   values.i13.TYPE[0] = _i13; \
 280   values.i14.TYPE[0] = _i14; \
 281   values.i15.TYPE[0] = _i15; \
 282   values.i16.TYPE[0] = _i16; \
 283   values.i17.TYPE[0] = _i17; \
 284   values.i18.TYPE[0] = _i18; \
 285   values.i19.TYPE[0] = _i19; \
 286   WRAP_CALL(_func1) (_i0, _i1, _i2, _i3, _i4, _i5, _i6, _i7, _i8, \
 287                      _i9, _i10, _i11, _i12, _i13, _i14, _i15, \
 288                      _i16, _i17, _i18, _i19); \
 289   clear_struct_registers; \
 290   fregs.F0.TYPE[0] = _i0; \
 291   fregs.F1.TYPE[0] = _i1; \
 292   fregs.F2.TYPE[0] = _i2; \
 293   fregs.F3.TYPE[0] = _i3; \
 294   fregs.F4.TYPE[0] = _i4; \
 295   fregs.F5.TYPE[0] = _i5; \
 296   fregs.F6.TYPE[0] = _i6; \
 297   fregs.F7.TYPE[0] = _i7; \
 298   num_fregs = 8; \
 299   WRAP_CALL(_func2) (_i0, _i1, _i2, _i3, _i4, _i5, _i6, _i7, _i8, \
 300                      _i9, _i10, _i11, _i12, _i13, _i14, _i15, \
 301                      _i16, _i17, _i18, _i19);
 302
 303 void
 304 test_m256_on_stack ()
 305 {
 306   __m256 x[8];
 307   int i;
 308   for (i = 0; i < 8; i++)
 309     x[i] = (__m256){32 + i, 0, 0, 0, 0, 0, 0, 0};
 310   pass = "m256-8";
 311   def_check_passing8 (x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7],
 312                       fun_check_passing_m256_8_values,
 313                       fun_check_passing_m256_8_regs, _m256);
 314 }
 315
 316 void
 317 test_m256h_on_stack ()
 318 {
 319   __m256h x[8];
 320   int i;
 321   for (i = 0; i < 8; i++)
 322     x[i] = (__m256h){1.1f16 + i, 2.1f16 + i, 3.1f16 + i, 4.1f16 + i,
 323                      5.1f16 + i, 6.1f16 + i, 7.1f16 + i, 8.1f16 + i,
 324                      9.1f16 + i, 10.1f16 + i, 11.1f16 + i, 12.1f16 + i,
 325                      13.1f16 + i, 14.1f16 + i, 15.1f16 + i, 16.1f16 + i};
 326   pass = "m256h-8";
 327   def_check_passing8 (x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7],
 328                       fun_check_passing_m256h_8_values,
 329                       fun_check_passing_m256h_8_regs, _m256h);
 330 }
 331
 332 void
 333 test_too_many_m256 ()
 334 {
 335   __m256 x[20];
 336   int i;
 337   for (i = 0; i < 20; i++)
 338     x[i] = (__m256){32 + i, 0, 0, 0, 0, 0, 0, 0};
 339   pass = "m256-20";
 340   def_check_passing20 (x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8],
 341                        x[9], x[10], x[11], x[12], x[13], x[14], x[15], x[16],
 342                        x[17], x[18], x[19], fun_check_passing_m256_20_values,
 343                        fun_check_passing_m256_20_regs, _m256);
 344 }
 345
 346 void
 347 test_too_many_m256h ()
 348 {
 349   __m256h x[20];
 350   int i;
 351   for (i = 0; i < 20; i++)
 352     x[i] = (__m256h){1.1f16 + i, 2.1f16 + i, 3.1f16 + i, 4.1f16 + i,
 353                      5.1f16 + i, 6.1f16 + i, 7.1f16 + i, 8.1f16 + i,
 354                      9.1f16 + i, 10.1f16 + i, 11.1f16 + i, 12.1f16 + i,
 355                      13.1f16 + i, 14.1f16 + i, 15.1f16 + i, 16.1f16 + i};
 356   pass = "m256h-20";
 357   def_check_passing20 (x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8],
 358                        x[9], x[10], x[11], x[12], x[13], x[14], x[15], x[16],
 359                        x[17], x[18], x[19], fun_check_passing_m256h_20_values,
 360                        fun_check_passing_m256h_20_regs, _m256h);
 361 }
 362
 363 static void
 364 do_test (void)
 365 {
 366   test_m256_on_stack ();
 367   test_too_many_m256 ();
 368   test_m256h_on_stack ();
 369   test_too_many_m256h ();
 370   if (failed)
 371     abort ();
 372 }