none/tests/amd64/bmi.c

   1
   2 #include <stdio.h>
   3
   4 typedef  unsigned long long int  ULong;
   5 typedef  unsigned int            UInt;
   6
   7 __attribute__((noinline))
   8 void do_andn64 ( /*OUT*/UInt* flags, /*OUT*/ULong* res, ULong arg1, ULong arg2 )
   9 {
  10   ULong tem, flag;
  11   __asm__ __volatile__(
  12     "movabsq $0x5555555555555555, %0" "\n\t"
  13     "andn %2, %3, %0"         "\n\t"
  14     "pushfq"                  "\n\t"
  15     "popq %1"                 "\n"
  16     : "=&r" (tem), "=r" (flag) : "r" (arg1), "r" (arg2) : "cc"
  17   );
  18   *res = tem;
  19   *flags = flag & 0x8d5;
  20   __asm__ __volatile__(
  21     "movabsq $0x5555555555555555, %0" "\n\t"
  22     "andn %2, %3, %0"         "\n\t"
  23     "pushfq"                  "\n\t"
  24     "popq %1"                 "\n"
  25     : "=&r" (tem), "=r" (flag) : "m" (arg1), "r" (arg2) : "cc"
  26   );
  27   if (*res != tem || *flags != (flag & 0x8d5))
  28      printf ("Difference between r and m variants\n");
  29 }
  30
  31 __attribute__((noinline))
  32 void do_andn32 ( /*OUT*/UInt* flags, /*OUT*/ULong* res, UInt arg1, UInt arg2 )
  33 {
  34   ULong tem, flag;
  35   __asm__ __volatile__(
  36     "movabsq $0x5555555555555555, %0" "\n\t"
  37     "andn %2, %3, %k0"        "\n\t"
  38     "pushfq"                  "\n\t"
  39     "popq %1"                 "\n"
  40     : "=&r" (tem), "=r" (flag) : "r" (arg1), "r" (arg2) : "cc"
  41   );
  42   *res = tem;
  43   *flags = flag & 0x8d5;
  44   __asm__ __volatile__(
  45     "movabsq $0x5555555555555555, %0" "\n\t"
  46     "andn %2, %3, %k0"        "\n\t"
  47     "pushfq"                  "\n\t"
  48     "popq %1"                 "\n"
  49     : "=&r" (tem), "=r" (flag) : "m" (arg1), "r" (arg2) : "cc"
  50   );
  51   if (*res != tem || *flags != (flag & 0x8d5))
  52      printf ("Difference between r and m variants\n");
  53 }
  54
  55
  56 __attribute__((noinline))
  57 void do_mulx64 ( /*OUT*/ULong* res1, /*OUT*/ULong* res2,
  58                  ULong arg1, ULong arg2 )
  59 {
  60   ULong tem1, tem2, flag1, flag2, flag3, flag4;
  61   __asm__ __volatile__(
  62     "movabsq $0x5555555555555555, %0" "\n\t"
  63     "movabsq $0x5555555555555555, %1" "\n\t"
  64     "movq %4, %%rdx"          "\n\t"
  65     "pushfq"                  "\n\t"
  66     "xorq $0x8d5, (%%rsp)"    "\n\t"
  67     "movq (%%rsp), %2"        "\n\t"
  68     "popfq"                   "\n\t"
  69     "mulx %5, %1, %0"         "\n\t"
  70     "pushfq"                  "\n\t"
  71     "movq (%%rsp), %3"        "\n\t"
  72     "xorq $0x8d5, (%%rsp)"    "\n\t"
  73     "popfq"                   "\n"
  74     : "=&r" (tem1), "=&r" (tem2), "=&r" (flag1), "=r" (flag2)
  75     : "g" (arg1), "r" (arg2) : "cc", "rdx"
  76   );
  77   *res1 = tem1;
  78   *res2 = tem2;
  79   __asm__ __volatile__(
  80     "movabsq $0x5555555555555555, %0" "\n\t"
  81     "movabsq $0x5555555555555555, %1" "\n\t"
  82     "movq %4, %%rdx"          "\n\t"
  83     "pushfq"                  "\n\t"
  84     "popq %2"                 "\n\t"
  85     "mulx %5, %1, %0"         "\n\t"
  86     "pushfq"                  "\n\t"
  87     "popq %3"                 "\n"
  88     : "=&r" (tem1), "=&r" (tem2), "=&r" (flag3), "=r" (flag4)
  89     : "g" (arg1), "m" (arg2) : "cc", "rdx"
  90   );
  91   if (*res1 != tem1 || *res2 != tem2)
  92      printf ("Difference between r and m variants\n");
  93   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
  94      printf ("Flags changed\n");
  95 }
  96
  97 __attribute__((noinline))
  98 void do_mulx32 ( /*OUT*/ULong* res1, /*OUT*/ULong* res2,
  99                  UInt arg1, UInt arg2 )
 100 {
 101   ULong tem1, tem2, flag1, flag2, flag3, flag4;
 102   __asm__ __volatile__(
 103     "movabsq $0x5555555555555555, %0" "\n\t"
 104     "movabsq $0x5555555555555555, %1" "\n\t"
 105     "movl %4, %%edx"          "\n\t"
 106     "pushfq"                  "\n\t"
 107     "xorq $0x8d5, (%%rsp)"    "\n\t"
 108     "movq (%%rsp), %2"        "\n\t"
 109     "popfq"                    "\n\t"
 110     "mulx %5, %k1, %k0"       "\n\t"
 111     "pushfq"                  "\n\t"
 112     "movq (%%rsp), %3"        "\n\t"
 113     "xorq $0x8d5, (%%rsp)"    "\n\t"
 114     "popfq"                   "\n"
 115     : "=&r" (tem1), "=&r" (tem2), "=&r" (flag1), "=r" (flag2)
 116     : "g" (arg1), "r" (arg2) : "cc", "rdx"
 117   );
 118   *res1 = tem1;
 119   *res2 = tem2;
 120   __asm__ __volatile__(
 121     "movabsq $0x5555555555555555, %0" "\n\t"
 122     "movabsq $0x5555555555555555, %1" "\n\t"
 123     "movl %4, %%edx"          "\n\t"
 124     "pushfq"                  "\n\t"
 125     "popq %2"                 "\n\t"
 126     "mulx %5, %k1, %k0"       "\n\t"
 127     "pushfq"                  "\n\t"
 128     "popq %3"                 "\n"
 129     : "=&r" (tem1), "=&r" (tem2), "=&r" (flag3), "=r" (flag4)
 130     : "g" (arg1), "m" (arg2) : "cc", "rdx"
 131   );
 132   if (*res1 != tem1 || *res2 != tem2)
 133      printf ("Difference between r and m variants\n");
 134   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 135      printf ("Flags changed\n");
 136 }
 137
 138
 139 __attribute__((noinline))
 140 void do_sarx64 ( /*OUT*/ULong* res, ULong arg1, ULong arg2 )
 141 {
 142   ULong tem, flag1, flag2, flag3, flag4;
 143   __asm__ __volatile__(
 144     "movabsq $0x5555555555555555, %0" "\n\t"
 145     "pushfq"                  "\n\t"
 146     "xorq $0x8d5, (%%rsp)"    "\n\t"
 147     "movq (%%rsp), %1"        "\n\t"
 148     "popfq"                   "\n\t"
 149     "sarx %3, %4, %0"         "\n\t"
 150     "pushfq"                  "\n\t"
 151     "movq (%%rsp), %2"        "\n\t"
 152     "xorq $0x8d5, (%%rsp)"    "\n\t"
 153     "popfq"                   "\n"
 154     : "=&r" (tem), "=&r" (flag1), "=r" (flag2)
 155     : "r" (arg1), "r" (arg2) : "cc"
 156   );
 157   *res = tem;
 158   __asm__ __volatile__(
 159     "movabsq $0x5555555555555555, %0" "\n\t"
 160     "pushfq"                  "\n\t"
 161     "xorq $0x8d5, (%%rsp)"    "\n\t"
 162     "movq (%%rsp), %1"        "\n\t"
 163     "popfq"                   "\n\t"
 164     "sarx %3, %4, %0"         "\n\t"
 165     "pushfq"                  "\n\t"
 166     "movq (%%rsp), %2"        "\n\t"
 167     "xorq $0x8d5, (%%rsp)"    "\n\t"
 168     "popfq"                   "\n"
 169     : "=&r" (tem), "=&r" (flag3), "=r" (flag4)
 170     : "r" (arg1), "m" (arg2) : "cc"
 171   );
 172   if (*res != tem)
 173      printf ("Difference between r and m variants\n");
 174   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 175      printf ("Flags changed\n");
 176 }
 177
 178 __attribute__((noinline))
 179 void do_sarx32 ( /*OUT*/ULong* res, UInt arg1, UInt arg2 )
 180 {
 181   ULong tem, flag1, flag2, flag3, flag4;
 182   __asm__ __volatile__(
 183     "movabsq $0x5555555555555555, %0" "\n\t"
 184     "pushfq"                  "\n\t"
 185     "xorq $0x8d5, (%%rsp)"    "\n\t"
 186     "movq (%%rsp), %1"        "\n\t"
 187     "popfq"                   "\n\t"
 188     "sarx %3, %4, %k0"        "\n\t"
 189     "pushfq"                  "\n\t"
 190     "movq (%%rsp), %2"        "\n\t"
 191     "xorq $0x8d5, (%%rsp)"    "\n\t"
 192     "popfq"                   "\n"
 193     : "=&r" (tem), "=&r" (flag1), "=r" (flag2)
 194     : "r" (arg1), "r" (arg2) : "cc"
 195   );
 196   *res = tem;
 197   __asm__ __volatile__(
 198     "movabsq $0x5555555555555555, %0" "\n\t"
 199     "pushfq"                  "\n\t"
 200     "xorq $0x8d5, (%%rsp)"    "\n\t"
 201     "movq (%%rsp), %1"        "\n\t"
 202     "popfq"                   "\n\t"
 203     "sarx %3, %4, %k0"        "\n\t"
 204     "pushfq"                  "\n\t"
 205     "movq (%%rsp), %2"        "\n\t"
 206     "xorq $0x8d5, (%%rsp)"    "\n\t"
 207     "popfq"                   "\n"
 208     : "=&r" (tem), "=&r" (flag3), "=r" (flag4)
 209     : "r" (arg1), "m" (arg2) : "cc"
 210   );
 211   if (*res != tem)
 212      printf ("Difference between r and m variants\n");
 213   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 214      printf ("Flags changed\n");
 215 }
 216
 217
 218 __attribute__((noinline))
 219 void do_shlx64 ( /*OUT*/ULong* res, ULong arg1, ULong arg2 )
 220 {
 221   ULong tem, flag1, flag2, flag3, flag4;
 222   __asm__ __volatile__(
 223     "movabsq $0x5555555555555555, %0" "\n\t"
 224     "pushfq"                  "\n\t"
 225     "xorq $0x8d5, (%%rsp)"    "\n\t"
 226     "movq (%%rsp), %1"        "\n\t"
 227     "popfq"                   "\n\t"
 228     "shlx %3, %4, %0"         "\n\t"
 229     "pushfq"                  "\n\t"
 230     "movq (%%rsp), %2"        "\n\t"
 231     "xorq $0x8d5, (%%rsp)"    "\n\t"
 232     "popfq"                   "\n"
 233     : "=&r" (tem), "=&r" (flag1), "=r" (flag2)
 234     : "r" (arg1), "r" (arg2) : "cc"
 235   );
 236   *res = tem;
 237   __asm__ __volatile__(
 238     "movabsq $0x5555555555555555, %0" "\n\t"
 239     "pushfq"                  "\n\t"
 240     "xorq $0x8d5, (%%rsp)"    "\n\t"
 241     "movq (%%rsp), %1"        "\n\t"
 242     "popfq"                   "\n\t"
 243     "shlx %3, %4, %0"         "\n\t"
 244     "pushfq"                  "\n\t"
 245     "movq (%%rsp), %2"        "\n\t"
 246     "xorq $0x8d5, (%%rsp)"    "\n\t"
 247     "popfq"                   "\n"
 248     : "=&r" (tem), "=&r" (flag3), "=r" (flag4)
 249     : "r" (arg1), "m" (arg2) : "cc"
 250   );
 251   if (*res != tem)
 252      printf ("Difference between r and m variants\n");
 253   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 254      printf ("Flags changed\n");
 255 }
 256
 257 __attribute__((noinline))
 258 void do_shlx32 ( /*OUT*/ULong* res, UInt arg1, UInt arg2 )
 259 {
 260   ULong tem, flag1, flag2, flag3, flag4;
 261   __asm__ __volatile__(
 262     "movabsq $0x5555555555555555, %0" "\n\t"
 263     "pushfq"                  "\n\t"
 264     "xorq $0x8d5, (%%rsp)"    "\n\t"
 265     "movq (%%rsp), %1"        "\n\t"
 266     "popfq"                   "\n\t"
 267     "shlx %3, %4, %k0"        "\n\t"
 268     "pushfq"                  "\n\t"
 269     "movq (%%rsp), %2"        "\n\t"
 270     "xorq $0x8d5, (%%rsp)"    "\n\t"
 271     "popfq"                   "\n"
 272     : "=&r" (tem), "=&r" (flag1), "=r" (flag2)
 273     : "r" (arg1), "r" (arg2) : "cc"
 274   );
 275   *res = tem;
 276   __asm__ __volatile__(
 277     "movabsq $0x5555555555555555, %0" "\n\t"
 278     "pushfq"                  "\n\t"
 279     "xorq $0x8d5, (%%rsp)"    "\n\t"
 280     "movq (%%rsp), %1"        "\n\t"
 281     "popfq"                   "\n\t"
 282     "shlx %3, %4, %k0"        "\n\t"
 283     "pushfq"                  "\n\t"
 284     "movq (%%rsp), %2"        "\n\t"
 285     "xorq $0x8d5, (%%rsp)"    "\n\t"
 286     "popfq"                   "\n"
 287     : "=&r" (tem), "=&r" (flag3), "=r" (flag4)
 288     : "r" (arg1), "m" (arg2) : "cc"
 289   );
 290   if (*res != tem)
 291      printf ("Difference between r and m variants\n");
 292   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 293      printf ("Flags changed\n");
 294 }
 295
 296
 297 __attribute__((noinline))
 298 void do_shrx64 ( /*OUT*/ULong* res, ULong arg1, ULong arg2 )
 299 {
 300   ULong tem, flag1, flag2, flag3, flag4;
 301   __asm__ __volatile__(
 302     "movabsq $0x5555555555555555, %0" "\n\t"
 303     "pushfq"                  "\n\t"
 304     "xorq $0x8d5, (%%rsp)"    "\n\t"
 305     "movq (%%rsp), %1"        "\n\t"
 306     "popfq"                   "\n\t"
 307     "shrx %3, %4, %0"         "\n\t"
 308     "pushfq"                  "\n\t"
 309     "movq (%%rsp), %2"        "\n\t"
 310     "xorq $0x8d5, (%%rsp)"    "\n\t"
 311     "popfq"                   "\n"
 312     : "=&r" (tem), "=&r" (flag1), "=r" (flag2)
 313     : "r" (arg1), "r" (arg2) : "cc"
 314   );
 315   *res = tem;
 316   __asm__ __volatile__(
 317     "movabsq $0x5555555555555555, %0" "\n\t"
 318     "pushfq"                  "\n\t"
 319     "xorq $0x8d5, (%%rsp)"    "\n\t"
 320     "movq (%%rsp), %1"        "\n\t"
 321     "popfq"                   "\n\t"
 322     "shrx %3, %4, %0"         "\n\t"
 323     "pushfq"                  "\n\t"
 324     "movq (%%rsp), %2"        "\n\t"
 325     "xorq $0x8d5, (%%rsp)"    "\n\t"
 326     "popfq"                   "\n"
 327     : "=&r" (tem), "=&r" (flag3), "=r" (flag4)
 328     : "r" (arg1), "m" (arg2) : "cc"
 329   );
 330   if (*res != tem)
 331      printf ("Difference between r and m variants\n");
 332   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 333      printf ("Flags changed\n");
 334 }
 335
 336 __attribute__((noinline))
 337 void do_shrx32 ( /*OUT*/ULong* res, UInt arg1, UInt arg2 )
 338 {
 339   ULong tem, flag1, flag2, flag3, flag4;
 340   __asm__ __volatile__(
 341     "movabsq $0x5555555555555555, %0" "\n\t"
 342     "pushfq"                  "\n\t"
 343     "xorq $0x8d5, (%%rsp)"    "\n\t"
 344     "movq (%%rsp), %1"        "\n\t"
 345     "popfq"                   "\n\t"
 346     "shrx %3, %4, %k0"        "\n\t"
 347     "pushfq"                  "\n\t"
 348     "movq (%%rsp), %2"        "\n\t"
 349     "xorq $0x8d5, (%%rsp)"    "\n\t"
 350     "popfq"                   "\n"
 351     : "=&r" (tem), "=&r" (flag1), "=r" (flag2)
 352     : "r" (arg1), "r" (arg2) : "cc"
 353   );
 354   *res = tem;
 355   __asm__ __volatile__(
 356     "movabsq $0x5555555555555555, %0" "\n\t"
 357     "pushfq"                  "\n\t"
 358     "xorq $0x8d5, (%%rsp)"    "\n\t"
 359     "movq (%%rsp), %1"        "\n\t"
 360     "popfq"                   "\n\t"
 361     "shrx %3, %4, %k0"        "\n\t"
 362     "pushfq"                  "\n\t"
 363     "movq (%%rsp), %2"        "\n\t"
 364     "xorq $0x8d5, (%%rsp)"    "\n\t"
 365     "popfq"                   "\n"
 366     : "=&r" (tem), "=&r" (flag3), "=r" (flag4)
 367     : "r" (arg1), "m" (arg2) : "cc"
 368   );
 369   if (*res != tem)
 370      printf ("Difference between r and m variants\n");
 371   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 372      printf ("Flags changed\n");
 373 }
 374
 375 ULong g_ulong_arg;
 376
 377 __attribute__((noinline))
 378 void do_rorx64 ( /*OUT*/ULong* res1, /*OUT*/ULong* res2, ULong arg )
 379 {
 380   ULong tem, flag1, flag2, flag3, flag4, flag5, flag6;
 381   __asm__ __volatile__(
 382     "movabsq $0x5555555555555555, %0" "\n\t"
 383     "pushfq"                  "\n\t"
 384     "xorq $0x8d5, (%%rsp)"    "\n\t"
 385     "movq (%%rsp), %1"        "\n\t"
 386     "popfq"                   "\n\t"
 387     "rorx $12, %3, %0"        "\n\t"
 388     "pushfq"                  "\n\t"
 389     "movq (%%rsp), %2"        "\n\t"
 390     "xorq $0x8d5, (%%rsp)"    "\n\t"
 391     "popfq"                   "\n"
 392     : "=&r" (tem), "=&r" (flag1), "=r" (flag2) : "r" (arg) : "cc"
 393   );
 394   *res1 = tem;
 395   __asm__ __volatile__(
 396     "movabsq $0x5555555555555555, %0" "\n\t"
 397     "pushfq"                  "\n\t"
 398     "xorq $0x8d5, (%%rsp)"    "\n\t"
 399     "movq (%%rsp), %1"        "\n\t"
 400     "popfq"                   "\n\t"
 401     "rorx $67, %3, %0"        "\n\t"
 402     "pushfq"                  "\n\t"
 403     "movq (%%rsp), %2"        "\n\t"
 404     "xorq $0x8d5, (%%rsp)"    "\n\t"
 405     "popfq"                   "\n"
 406     : "=&r" (tem), "=&r" (flag3), "=r" (flag4) : "m" (arg) : "cc"
 407   );
 408   *res2 = tem;
 409   /* rip-relative memory access */
 410   g_ulong_arg = arg;
 411   __asm__ __volatile__(
 412     "movabsq $0x5555555555555555, %0" "\n\t"
 413     "pushfq"                  "\n\t"
 414     "xorq $0x8d5, (%%rsp)"    "\n\t"
 415     "movq (%%rsp), %1"        "\n\t"
 416     "popfq"                   "\n\t"
 417 #if defined(__APPLE__)
 418     "rorx $67, _g_ulong_arg(%%rip), %0" "\n\t"
 419 #else
 420     "rorx $67, g_ulong_arg(%%rip), %0" "\n\t"
 421 #endif
 422     "pushfq"                  "\n\t"
 423     "movq (%%rsp), %2"        "\n\t"
 424     "xorq $0x8d5, (%%rsp)"    "\n\t"
 425     "popfq"                   "\n"
 426     : "=&r" (tem), "=&r" (flag5), "=r" (flag6) : : "memory", "cc"
 427   );
 428   if (*res2 != tem)
 429      printf ("Difference between m-variants\n");
 430   if (((flag1 ^ flag2) | (flag3 ^ flag4) | (flag5 ^ flag6)) & 0x8d5)
 431      printf ("Flags changed\n");
 432 }
 433
 434 UInt g_uint_arg;
 435
 436 __attribute__((noinline))
 437 void do_rorx32 ( /*OUT*/ULong* res1, /*OUT*/ULong* res2, UInt arg )
 438 {
 439   ULong tem, flag1, flag2, flag3, flag4, flag5, flag6;
 440   __asm__ __volatile__(
 441     "movabsq $0x5555555555555555, %0" "\n\t"
 442     "pushfq"                  "\n\t"
 443     "xorq $0x8d5, (%%rsp)"    "\n\t"
 444     "movq (%%rsp), %1"        "\n\t"
 445     "popfq"                   "\n\t"
 446     "rorx $12, %3, %k0"       "\n\t"
 447     "pushfq"                  "\n\t"
 448     "movq (%%rsp), %2"        "\n\t"
 449     "xorq $0x8d5, (%%rsp)"    "\n\t"
 450     "popfq"                   "\n"
 451     : "=&r" (tem), "=&r" (flag1), "=r" (flag2) : "r" (arg) : "cc"
 452   );
 453   *res1 = tem;
 454   __asm__ __volatile__(
 455     "movabsq $0x5555555555555555, %0" "\n\t"
 456     "pushfq"                  "\n\t"
 457     "xorq $0x8d5, (%%rsp)"    "\n\t"
 458     "movq (%%rsp), %1"        "\n\t"
 459     "popfq"                   "\n\t"
 460     "rorx $67, %3, %k0"       "\n\t"
 461     "pushfq"                  "\n\t"
 462     "movq (%%rsp), %2"        "\n\t"
 463     "xorq $0x8d5, (%%rsp)"    "\n\t"
 464     "popfq"                   "\n"
 465     : "=&r" (tem), "=&r" (flag3), "=r" (flag4) : "m" (arg) : "cc"
 466   );
 467   *res2 = tem;
 468   /* rip-relative memory access */
 469   g_uint_arg = arg;
 470   __asm__ __volatile__(
 471     "movabsq $0x5555555555555555, %0" "\n\t"
 472     "pushfq"                  "\n\t"
 473     "xorq $0x8d5, (%%rsp)"    "\n\t"
 474     "movq (%%rsp), %1"        "\n\t"
 475     "popfq"                   "\n\t"
 476 #if defined(__APPLE__)
 477     "rorx $67, _g_uint_arg(%%rip), %k0" "\n\t"
 478 #else
 479     "rorx $67, g_uint_arg(%%rip), %k0" "\n\t"
 480 #endif
 481     "pushfq"                  "\n\t"
 482     "movq (%%rsp), %2"        "\n\t"
 483     "xorq $0x8d5, (%%rsp)"    "\n\t"
 484     "popfq"                   "\n"
 485     : "=&r" (tem), "=&r" (flag5), "=r" (flag6) : : "memory", "cc"
 486   );
 487   if (*res2 != tem)
 488      printf ("Difference between m-variants\n");
 489   if (((flag1 ^ flag2) | (flag3 ^ flag4) | (flag5 ^ flag6)) & 0x8d5)
 490      printf ("Flags changed\n");
 491 }
 492
 493
 494 __attribute__((noinline))
 495 void do_blsi64 ( /*OUT*/UInt* flags, /*OUT*/ULong* res, ULong arg )
 496 {
 497   ULong tem, flag;
 498   __asm__ __volatile__(
 499     "movabsq $0x5555555555555555, %0" "\n\t"
 500     "blsi %2, %0"             "\n\t"
 501     "pushfq"                  "\n\t"
 502     "popq %1"                 "\n"
 503     : "=&r" (tem), "=&r" (flag) : "r" (arg) : "cc"
 504   );
 505   *res = tem;
 506   *flags = flag & 0x8d5;
 507   __asm__ __volatile__(
 508     "movabsq $0x5555555555555555, %0" "\n\t"
 509     "blsi %2, %0"             "\n\t"
 510     "pushfq"                  "\n\t"
 511     "popq %1"                 "\n"
 512     : "=&r" (tem), "=&r" (flag) : "m" (arg) : "cc"
 513   );
 514   if (*res != tem || *flags != (flag & 0x8d5))
 515      printf ("Difference between r and m variants\n");
 516 }
 517
 518 __attribute__((noinline))
 519 void do_blsi32 ( /*OUT*/UInt* flags, /*OUT*/ULong* res, UInt arg )
 520 {
 521   ULong tem, flag;
 522   __asm__ __volatile__(
 523     "movabsq $0x5555555555555555, %0" "\n\t"
 524     "blsi %2, %k0"            "\n\t"
 525     "pushfq"                  "\n\t"
 526     "popq %1"                 "\n"
 527     : "=&r" (tem), "=&r" (flag) : "r" (arg) : "cc"
 528   );
 529   *res = tem;
 530   *flags = flag & 0x8d5;
 531   __asm__ __volatile__(
 532     "movabsq $0x5555555555555555, %0" "\n\t"
 533     "blsi %2, %k0"            "\n\t"
 534     "pushfq"                  "\n\t"
 535     "popq %1"                 "\n"
 536     : "=&r" (tem), "=&r" (flag) : "m" (arg) : "cc"
 537   );
 538   if (*res != tem || *flags != (flag & 0x8d5))
 539      printf ("Difference between r and m variants\n");
 540 }
 541
 542
 543 __attribute__((noinline))
 544 void do_blsmsk64 ( /*OUT*/UInt* flags, /*OUT*/ULong* res, ULong arg )
 545 {
 546   ULong tem, flag;
 547   __asm__ __volatile__(
 548     "movabsq $0x5555555555555555, %0" "\n\t"
 549     "blsmsk %2, %0"           "\n\t"
 550     "pushfq"                  "\n\t"
 551     "popq %1"                 "\n"
 552     : "=&r" (tem), "=&r" (flag) : "r" (arg) : "cc"
 553   );
 554   *res = tem;
 555   *flags = flag & 0x8d5;
 556   __asm__ __volatile__(
 557     "movabsq $0x5555555555555555, %0" "\n\t"
 558     "blsmsk %2, %0"           "\n\t"
 559     "pushfq"                  "\n\t"
 560     "popq %1"                 "\n"
 561     : "=&r" (tem), "=&r" (flag) : "m" (arg) : "cc"
 562   );
 563   if (*res != tem || *flags != (flag & 0x8d5))
 564      printf ("Difference between r and m variants\n");
 565 }
 566
 567 __attribute__((noinline))
 568 void do_blsmsk32 ( /*OUT*/UInt* flags, /*OUT*/ULong* res, UInt arg )
 569 {
 570   ULong tem, flag;
 571   __asm__ __volatile__(
 572     "movabsq $0x5555555555555555, %0" "\n\t"
 573     "blsmsk %2, %k0"          "\n\t"
 574     "pushfq"                  "\n\t"
 575     "popq %1"                 "\n"
 576     : "=&r" (tem), "=&r" (flag) : "r" (arg) : "cc"
 577   );
 578   *res = tem;
 579   *flags = flag & 0x8d5;
 580   __asm__ __volatile__(
 581     "movabsq $0x5555555555555555, %0" "\n\t"
 582     "blsmsk %2, %k0"          "\n\t"
 583     "pushfq"                  "\n\t"
 584     "popq %1"                 "\n"
 585     : "=&r" (tem), "=&r" (flag) : "m" (arg) : "cc"
 586   );
 587   if (*res != tem || *flags != (flag & 0x8d5))
 588      printf ("Difference between r and m variants\n");
 589 }
 590
 591
 592 __attribute__((noinline))
 593 void do_blsr64 ( /*OUT*/UInt* flags, /*OUT*/ULong* res, ULong arg )
 594 {
 595   ULong tem, flag;
 596   __asm__ __volatile__(
 597     "movabsq $0x5555555555555555, %0" "\n\t"
 598     "blsr %2, %0"             "\n\t"
 599     "pushfq"                  "\n\t"
 600     "popq %1"                 "\n"
 601     : "=&r" (tem), "=&r" (flag) : "r" (arg) : "cc"
 602   );
 603   *res = tem;
 604   *flags = flag & 0x8d5;
 605   __asm__ __volatile__(
 606     "movabsq $0x5555555555555555, %0" "\n\t"
 607     "blsr %2, %0"             "\n\t"
 608     "pushfq"                  "\n\t"
 609     "popq %1"                 "\n"
 610     : "=&r" (tem), "=&r" (flag) : "m" (arg) : "cc"
 611   );
 612   if (*res != tem || *flags != (flag & 0x8d5))
 613      printf ("Difference between r and m variants\n");
 614 }
 615
 616 __attribute__((noinline))
 617 void do_blsr32 ( /*OUT*/UInt* flags, /*OUT*/ULong* res, UInt arg )
 618 {
 619   ULong tem, flag;
 620   __asm__ __volatile__(
 621     "movabsq $0x5555555555555555, %0" "\n\t"
 622     "blsr %2, %k0"            "\n\t"
 623     "pushfq"                  "\n\t"
 624     "popq %1"                 "\n"
 625     : "=&r" (tem), "=&r" (flag) : "r" (arg) : "cc"
 626   );
 627   *res = tem;
 628   *flags = flag & 0x8d5;
 629   __asm__ __volatile__(
 630     "movabsq $0x5555555555555555, %0" "\n\t"
 631     "blsr %2, %k0"            "\n\t"
 632     "pushfq"                  "\n\t"
 633     "popq %1"                 "\n"
 634     : "=&r" (tem), "=&r" (flag) : "m" (arg) : "cc"
 635   );
 636   if (*res != tem || *flags != (flag & 0x8d5))
 637      printf ("Difference between r and m variants\n");
 638 }
 639
 640
 641 __attribute__((noinline))
 642 void do_bextr64 ( /*OUT*/UInt* flags, /*OUT*/ULong* res,
 643                   ULong arg1, ULong arg2 )
 644 {
 645   ULong tem, flag;
 646   __asm__ __volatile__(
 647     "movabsq $0x5555555555555555, %0" "\n\t"
 648     "bextr %2, %3, %0"        "\n\t"
 649     "pushfq"                  "\n\t"
 650     "popq %1"                 "\n"
 651     : "=&r" (tem), "=&r" (flag) : "r" (arg1), "r" (arg2) : "cc"
 652   );
 653   *res = tem;
 654   *flags = flag & 0x8d5;
 655   __asm__ __volatile__(
 656     "movabsq $0x5555555555555555, %0" "\n\t"
 657     "bextr %2, %3, %0"        "\n\t"
 658     "pushfq"                  "\n\t"
 659     "popq %1"                 "\n"
 660     : "=&r" (tem), "=&r" (flag) : "r" (arg1), "m" (arg2) : "cc"
 661   );
 662   if (*res != tem || *flags != (flag & 0x8d5))
 663      printf ("Difference between r and m variants\n");
 664 }
 665
 666 __attribute__((noinline))
 667 void do_bextr32 ( /*OUT*/UInt* flags, /*OUT*/ULong* res,
 668                   UInt arg1, UInt arg2 )
 669 {
 670   ULong tem, flag;
 671   __asm__ __volatile__(
 672     "movabsq $0x5555555555555555, %0" "\n\t"
 673     "bextr %2, %3, %k0"       "\n\t"
 674     "pushfq"                  "\n\t"
 675     "popq %1"                 "\n"
 676     : "=&r" (tem), "=&r" (flag) : "r" (arg1), "r" (arg2) : "cc"
 677   );
 678   *res = tem;
 679   *flags = flag & 0x8d5;
 680   __asm__ __volatile__(
 681     "movabsq $0x5555555555555555, %0" "\n\t"
 682     "bextr %2, %3, %k0"       "\n\t"
 683     "pushfq"                  "\n\t"
 684     "popq %1"                 "\n"
 685     : "=&r" (tem), "=&r" (flag) : "r" (arg1), "m" (arg2) : "cc"
 686   );
 687   if (*res != tem || *flags != (flag & 0x8d5))
 688      printf ("Difference between r and m variants\n");
 689 }
 690
 691
 692 __attribute__((noinline))
 693 void do_bzhi64 ( /*OUT*/UInt* flags, /*OUT*/ULong* res,
 694                  ULong arg1, ULong arg2 )
 695 {
 696   ULong tem, flag;
 697   __asm__ __volatile__(
 698     "movabsq $0x5555555555555555, %0" "\n\t"
 699     "bzhi %2, %3, %0"         "\n\t"
 700     "pushfq"                  "\n\t"
 701     "popq %1"                 "\n"
 702     : "=&r" (tem), "=&r" (flag) : "r" (arg1), "r" (arg2) : "cc"
 703   );
 704   *res = tem;
 705   *flags = flag & 0x8d5;
 706   __asm__ __volatile__(
 707     "movabsq $0x5555555555555555, %0" "\n\t"
 708     "bzhi %2, %3, %0"         "\n\t"
 709     "pushfq"                  "\n\t"
 710     "popq %1"                 "\n"
 711     : "=&r" (tem), "=&r" (flag) : "r" (arg1), "m" (arg2) : "cc"
 712   );
 713   if (*res != tem || *flags != (flag & 0x8d5))
 714      printf ("Difference between r and m variants\n");
 715 }
 716
 717 __attribute__((noinline))
 718 void do_bzhi32 ( /*OUT*/UInt* flags, /*OUT*/ULong* res,
 719                  UInt arg1, UInt arg2 )
 720 {
 721   ULong tem, flag;
 722   __asm__ __volatile__(
 723     "movabsq $0x5555555555555555, %0" "\n\t"
 724     "bzhi %2, %3, %k0"        "\n\t"
 725     "pushfq"                  "\n\t"
 726     "popq %1"                 "\n"
 727     : "=&r" (tem), "=&r" (flag) : "r" (arg1), "r" (arg2) : "cc"
 728   );
 729   *res = tem;
 730   *flags = flag & 0x8d5;
 731   __asm__ __volatile__(
 732     "movabsq $0x5555555555555555, %0" "\n\t"
 733     "bzhi %2, %3, %k0"        "\n\t"
 734     "pushfq"                  "\n\t"
 735     "popq %1"                 "\n"
 736     : "=&r" (tem), "=&r" (flag) : "r" (arg1), "m" (arg2) : "cc"
 737   );
 738   if (*res != tem || *flags != (flag & 0x8d5))
 739      printf ("Difference between r and m variants\n");
 740 }
 741
 742
 743 __attribute__((noinline))
 744 void do_pdep64 ( /*OUT*/ULong* res, ULong arg1, ULong arg2 )
 745 {
 746   ULong tem, flag1, flag2, flag3, flag4;
 747   __asm__ __volatile__(
 748     "movabsq $0x5555555555555555, %0" "\n\t"
 749     "pushfq"                  "\n\t"
 750     "xorq $0x8d5, (%%rsp)"    "\n\t"
 751     "movq (%%rsp), %1"        "\n\t"
 752     "popfq"                   "\n\t"
 753     "pdep %3, %4, %0"         "\n\t"
 754     "pushfq"                  "\n\t"
 755     "movq (%%rsp), %2"        "\n\t"
 756     "xorq $0x8d5, (%%rsp)"    "\n\t"
 757     "popfq"                   "\n"
 758     : "=&r" (tem), "=&r" (flag1), "=r" (flag2)
 759     : "r" (arg1), "r" (arg2) : "cc"
 760   );
 761   *res = tem;
 762   __asm__ __volatile__(
 763     "movabsq $0x5555555555555555, %0" "\n\t"
 764     "pushfq"                  "\n\t"
 765     "xorq $0x8d5, (%%rsp)"    "\n\t"
 766     "movq (%%rsp), %1"        "\n\t"
 767     "popfq"                   "\n\t"
 768     "pdep %3, %4, %0"         "\n\t"
 769     "pushfq"                  "\n\t"
 770     "movq (%%rsp), %2"        "\n\t"
 771     "xorq $0x8d5, (%%rsp)"    "\n\t"
 772     "popfq"                   "\n"
 773     : "=&r" (tem), "=&r" (flag3), "=r" (flag4)
 774     : "m" (arg1), "r" (arg2) : "cc"
 775   );
 776   if (*res != tem)
 777      printf ("Difference between r and m variants\n");
 778   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 779      printf ("Flags changed\n");
 780 }
 781
 782 __attribute__((noinline))
 783 void do_pdep32 ( /*OUT*/ULong* res, UInt arg1, UInt arg2 )
 784 {
 785   ULong tem, flag1, flag2, flag3, flag4;
 786   __asm__ __volatile__(
 787     "movabsq $0x5555555555555555, %0" "\n\t"
 788     "pushfq"                  "\n\t"
 789     "xorq $0x8d5, (%%rsp)"    "\n\t"
 790     "movq (%%rsp), %1"        "\n\t"
 791     "popfq"                   "\n\t"
 792     "pdep %3, %4, %k0"        "\n\t"
 793     "pushfq"                  "\n\t"
 794     "movq (%%rsp), %2"        "\n\t"
 795     "xorq $0x8d5, (%%rsp)"    "\n\t"
 796     "popfq"                   "\n"
 797     : "=&r" (tem), "=&r" (flag1), "=r" (flag2)
 798     : "r" (arg1), "r" (arg2) : "cc"
 799   );
 800   *res = tem;
 801   __asm__ __volatile__(
 802     "movabsq $0x5555555555555555, %0" "\n\t"
 803     "pushfq"                  "\n\t"
 804     "xorq $0x8d5, (%%rsp)"    "\n\t"
 805     "movq (%%rsp), %1"        "\n\t"
 806     "popfq"                   "\n\t"
 807     "pdep %3, %4, %k0"        "\n\t"
 808     "pushfq"                  "\n\t"
 809     "movq (%%rsp), %2"        "\n\t"
 810     "xorq $0x8d5, (%%rsp)"    "\n\t"
 811     "popfq"                   "\n"
 812     : "=&r" (tem), "=&r" (flag3), "=r" (flag4)
 813     : "m" (arg1), "r" (arg2) : "cc"
 814   );
 815   if (*res != tem)
 816      printf ("Difference between r and m variants\n");
 817   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 818      printf ("Flags changed\n");
 819 }
 820
 821
 822 __attribute__((noinline))
 823 void do_pext64 ( /*OUT*/ULong* res, ULong arg1, ULong arg2 )
 824 {
 825   ULong tem, flag1, flag2, flag3, flag4;
 826   __asm__ __volatile__(
 827     "movabsq $0x5555555555555555, %0" "\n\t"
 828     "pushfq"                  "\n\t"
 829     "xorq $0x8d5, (%%rsp)"    "\n\t"
 830     "movq (%%rsp), %1"        "\n\t"
 831     "popfq"                   "\n\t"
 832     "pext %3, %4, %0"         "\n\t"
 833     "pushfq"                  "\n\t"
 834     "movq (%%rsp), %2"        "\n\t"
 835     "xorq $0x8d5, (%%rsp)"    "\n\t"
 836     "popfq"                   "\n"
 837     : "=&r" (tem), "=&r" (flag1), "=r" (flag2)
 838     : "r" (arg1), "r" (arg2) : "cc"
 839   );
 840   *res = tem;
 841   __asm__ __volatile__(
 842     "movabsq $0x5555555555555555, %0" "\n\t"
 843     "pushfq"                  "\n\t"
 844     "xorq $0x8d5, (%%rsp)"    "\n\t"
 845     "movq (%%rsp), %1"        "\n\t"
 846     "popfq"                   "\n\t"
 847     "pext %3, %4, %0"         "\n\t"
 848     "pushfq"                  "\n\t"
 849     "movq (%%rsp), %2"        "\n\t"
 850     "xorq $0x8d5, (%%rsp)"    "\n\t"
 851     "popfq"                   "\n"
 852     : "=&r" (tem), "=&r" (flag3), "=r" (flag4)
 853     : "m" (arg1), "r" (arg2) : "cc"
 854   );
 855   if (*res != tem)
 856      printf ("Difference between r and m variants\n");
 857   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 858      printf ("Flags changed\n");
 859 }
 860
 861 __attribute__((noinline))
 862 void do_pext32 ( /*OUT*/ULong* res, UInt arg1, UInt arg2 )
 863 {
 864   ULong tem, flag1, flag2, flag3, flag4;
 865   __asm__ __volatile__(
 866     "movabsq $0x5555555555555555, %0" "\n\t"
 867     "pushfq"                  "\n\t"
 868     "xorq $0x8d5, (%%rsp)"    "\n\t"
 869     "movq (%%rsp), %1"        "\n\t"
 870     "popfq"                   "\n\t"
 871     "pext %3, %4, %k0"        "\n\t"
 872     "pushfq"                  "\n\t"
 873     "movq (%%rsp), %2"        "\n\t"
 874     "xorq $0x8d5, (%%rsp)"    "\n\t"
 875     "popfq"                   "\n"
 876     : "=&r" (tem), "=&r" (flag1), "=r" (flag2)
 877     : "r" (arg1), "r" (arg2) : "cc"
 878   );
 879   *res = tem;
 880   __asm__ __volatile__(
 881     "movabsq $0x5555555555555555, %0" "\n\t"
 882     "pushfq"                  "\n\t"
 883     "xorq $0x8d5, (%%rsp)"    "\n\t"
 884     "movq (%%rsp), %1"        "\n\t"
 885     "popfq"                   "\n\t"
 886     "pext %3, %4, %k0"        "\n\t"
 887     "pushfq"                  "\n\t"
 888     "movq (%%rsp), %2"        "\n\t"
 889     "xorq $0x8d5, (%%rsp)"    "\n\t"
 890     "popfq"                   "\n"
 891     : "=&r" (tem), "=&r" (flag3), "=r" (flag4)
 892     : "m" (arg1), "r" (arg2) : "cc"
 893   );
 894   if (*res != tem)
 895      printf ("Difference between r and m variants\n");
 896   if (((flag1 ^ flag2) | (flag3 ^ flag4)) & 0x8d5)
 897      printf ("Flags changed\n");
 898 }
 899
 900
 901 int main ( void )
 902 {
 903    ULong w1, w2;
 904
 905    w1 = 0xFEDC192837475675ULL;
 906    w2 = 0x57657438291CDEF0ULL;
 907    while (1) {
 908       ULong res;
 909       UInt  flags;
 910       do_andn64(&flags, &res, w1, w2);
 911       printf("andn64 %016llx %016llx -> %016llx %04x\n", w1, w2, res, flags);
 912       if (w1 == 0) break;
 913       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
 914       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
 915    }
 916
 917    w1 = 0xFEDC192837475675ULL;
 918    w2 = 0x57657438291CDEF0ULL;
 919    while (1) {
 920       ULong res;
 921       UInt  flags;
 922       do_andn32(&flags, &res, w1, w2);
 923       printf("andn32 %016llx %016llx -> %016llx %04x\n", w1, w2, res, flags);
 924       if (w1 == 0) break;
 925       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
 926       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
 927    }
 928
 929    w1 = 0xFEDC192837475675ULL;
 930    w2 = 0x57657438291CDEF0ULL;
 931    while (1) {
 932       ULong res1, res2;
 933       do_mulx64(&res1, &res2, w1, w2);
 934       printf("mulx64 %016llx %016llx -> %016llx %016llx\n", w1, w2, res1, res2);
 935       if (w1 == 0) break;
 936       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
 937       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
 938    }
 939
 940    w1 = 0xFEDC192837475675ULL;
 941    w2 = 0x57657438291CDEF0ULL;
 942    while (1) {
 943       ULong res1, res2;
 944       do_mulx32(&res1, &res2, w1, w2);
 945       printf("mulx32 %016llx %016llx -> %016llx %016llx\n", w1, w2, res1, res2);
 946       if (w1 == 0) break;
 947       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
 948       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
 949    }
 950
 951    w1 = 0xFEDC192837475675ULL;
 952    w2 = 0x57657438291CDEF0ULL;
 953    while (1) {
 954       ULong res;
 955       do_sarx64(&res, w1, w2);
 956       printf("sarx64 %016llx %016llx -> %016llx\n", w1, w2, res);
 957       if (w1 == 0) break;
 958       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
 959       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
 960    }
 961
 962    w1 = 0xFEDC192837475675ULL;
 963    w2 = 0x57657438291CDEF0ULL;
 964    while (1) {
 965       ULong res;
 966       do_sarx32(&res, w1, w2);
 967       printf("sarx32 %016llx %016llx -> %016llx\n", w1, w2, res);
 968       if (w1 == 0) break;
 969       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
 970       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
 971    }
 972
 973    w1 = 0xFEDC192837475675ULL;
 974    w2 = 0x57657438291CDEF0ULL;
 975    while (1) {
 976       ULong res;
 977       do_shlx64(&res, w1, w2);
 978       printf("shlx64 %016llx %016llx -> %016llx\n", w1, w2, res);
 979       if (w1 == 0) break;
 980       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
 981       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
 982    }
 983
 984    w1 = 0xFEDC192837475675ULL;
 985    w2 = 0x57657438291CDEF0ULL;
 986    while (1) {
 987       ULong res;
 988       do_shlx32(&res, w1, w2);
 989       printf("shlx32 %016llx %016llx -> %016llx\n", w1, w2, res);
 990       if (w1 == 0) break;
 991       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
 992       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
 993    }
 994
 995    w1 = 0xFEDC192837475675ULL;
 996    w2 = 0x57657438291CDEF0ULL;
 997    while (1) {
 998       ULong res;
 999       do_shrx64(&res, w1, w2);
1000       printf("shrx64 %016llx %016llx -> %016llx\n", w1, w2, res);
1001       if (w1 == 0) break;
1002       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1003       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
1004    }
1005
1006    w1 = 0xFEDC192837475675ULL;
1007    w2 = 0x57657438291CDEF0ULL;
1008    while (1) {
1009       ULong res;
1010       do_shrx32(&res, w1, w2);
1011       printf("shrx32 %016llx %016llx -> %016llx\n", w1, w2, res);
1012       if (w1 == 0) break;
1013       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1014       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
1015    }
1016
1017    w1 = 0xFEDC192837475675ULL;
1018    while (1) {
1019       ULong res1, res2;
1020       do_rorx64(&res1, &res2, w1);
1021       printf("rorx64 %016llx -> %016llx %016llx\n", w1, res1, res2);
1022       if (w1 == 0) break;
1023       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1024    }
1025
1026    w1 = 0xFEDC192837475675ULL;
1027    while (1) {
1028       ULong res1, res2;
1029       do_rorx32(&res1, &res2, w1);
1030       printf("rorx32 %016llx -> %016llx %016llx\n", w1, res1, res2);
1031       if (w1 == 0) break;
1032       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1033    }
1034
1035    w1 = 0xFEDC192837475675ULL;
1036    while (1) {
1037       ULong res;
1038       UInt  flags;
1039       do_blsi64(&flags, &res, w1);
1040       printf("blsi64 %016llx -> %016llx %04x\n", w1, res, flags);
1041       if (w1 == 0) break;
1042       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1043    }
1044
1045    w1 = 0xFEDC192837475675ULL;
1046    while (1) {
1047       ULong res;
1048       UInt  flags;
1049       do_blsi32(&flags, &res, w1);
1050       printf("blsi32 %016llx -> %016llx %04x\n", w1, res, flags);
1051       if (w1 == 0) break;
1052       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1053    }
1054
1055    w1 = 0xFEDC192837475675ULL;
1056    while (1) {
1057       ULong res;
1058       UInt  flags;
1059       do_blsmsk64(&flags, &res, w1);
1060       printf("blsmsk64 %016llx -> %016llx %04x\n", w1, res, flags);
1061       if (w1 == 0) break;
1062       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1063    }
1064
1065    w1 = 0xFEDC192837475675ULL;
1066    while (1) {
1067       ULong res;
1068       UInt  flags;
1069       do_blsmsk32(&flags, &res, w1);
1070       printf("blsmsk32 %016llx -> %016llx %04x\n", w1, res, flags);
1071       if (w1 == 0) break;
1072       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1073    }
1074
1075    w1 = 0xFEDC192837475675ULL;
1076    while (1) {
1077       ULong res;
1078       UInt  flags;
1079       do_blsr64(&flags, &res, w1);
1080       printf("blsr64 %016llx -> %016llx %04x\n", w1, res, flags);
1081       if (w1 == 0) break;
1082       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1083    }
1084
1085    w1 = 0xFEDC192837475675ULL;
1086    while (1) {
1087       ULong res;
1088       UInt  flags;
1089       do_blsr32(&flags, &res, w1);
1090       printf("blsr32 %016llx -> %016llx %04x\n", w1, res, flags);
1091       if (w1 == 0) break;
1092       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1093    }
1094
1095    w1 = 0xFEDC192837475675ULL;
1096    w2 = 0x57657438291CDEF0ULL;
1097    while (1) {
1098       ULong res;
1099       UInt  flags;
1100       do_bextr64(&flags, &res, w1, w2);
1101       printf("bextr64 %016llx %016llx -> %016llx %04x\n", w1, w2, res, flags);
1102       if (w1 == 0) break;
1103       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1104       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
1105    }
1106
1107    w1 = 0xFEDC192837475675ULL;
1108    w2 = 0x57657438291CDEF0ULL;
1109    while (1) {
1110       ULong res;
1111       UInt  flags;
1112       do_bextr32(&flags, &res, w1, w2);
1113       printf("bextr32 %016llx %016llx -> %016llx %04x\n", w1, w2, res, flags);
1114       if (w1 == 0) break;
1115       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1116       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
1117    }
1118
1119    w1 = 0xFEDC192837475675ULL;
1120    w2 = 0x57657438291CDEF0ULL;
1121    while (1) {
1122       ULong res;
1123       UInt  flags;
1124       do_bzhi64(&flags, &res, w1, w2);
1125       printf("bzhi64 %016llx %016llx -> %016llx %04x\n", w1, w2, res, flags);
1126       if (w1 == 0) break;
1127       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1128       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
1129    }
1130
1131    w1 = 0xFEDC192837475675ULL;
1132    w2 = 0x57657438291CDEF0ULL;
1133    while (1) {
1134       ULong res;
1135       UInt  flags;
1136       do_bzhi32(&flags, &res, w1, w2);
1137       printf("bzhi32 %016llx %016llx -> %016llx %04x\n", w1, w2, res, flags);
1138       if (w1 == 0) break;
1139       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1140       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
1141    }
1142
1143    w1 = 0xFEDC192837475675ULL;
1144    w2 = 0x57657438291CDEF0ULL;
1145    while (1) {
1146       ULong res;
1147       do_pdep64(&res, w1, w2);
1148       printf("pdep64 %016llx %016llx -> %016llx\n", w1, w2, res);
1149       if (w1 == 0) break;
1150       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1151       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
1152    }
1153
1154    w1 = 0xFEDC192837475675ULL;
1155    w2 = 0x57657438291CDEF0ULL;
1156    while (1) {
1157       ULong res;
1158       do_pdep32(&res, w1, w2);
1159       printf("pdep32 %016llx %016llx -> %016llx\n", w1, w2, res);
1160       if (w1 == 0) break;
1161       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1162       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
1163    }
1164
1165    w1 = 0xFEDC192837475675ULL;
1166    w2 = 0x57657438291CDEF0ULL;
1167    while (1) {
1168       ULong res;
1169       do_pext64(&res, w1, w2);
1170       printf("pext64 %016llx %016llx -> %016llx\n", w1, w2, res);
1171       if (w1 == 0) break;
1172       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1173       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
1174    }
1175
1176    w1 = 0xFEDC192837475675ULL;
1177    w2 = 0x57657438291CDEF0ULL;
1178    while (1) {
1179       ULong res;
1180       do_pext32(&res, w1, w2);
1181       printf("pext32 %016llx %016llx -> %016llx\n", w1, w2, res);
1182       if (w1 == 0) break;
1183       w1 = ((w1 >> 2) | (w1 >> 1)) + (w1 / 17ULL);
1184       w2 = ((w2 >> 2) | (w2 >> 1)) + (w2 / 17ULL);
1185    }
1186
1187    return 0;
1188 }