1 /*
   2  * Copyright (c) 2022, 2025, Arm Limited. All rights reserved.
   3  * Copyright (c) 2023, 2026, Oracle and/or its affiliates. All rights reserved.
   4  * Copyright (c) 2025, Rivos Inc. All rights reserved.
   5  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   6  *
   7  * This code is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 only, as
   9  * published by the Free Software Foundation.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package compiler.c2.cmove;
  27 
  28 import compiler.lib.ir_framework.*;
  29 import java.util.Random;
  30 import jdk.test.lib.Asserts;
  31 import jdk.test.lib.Utils;
  32 
  33 /*
  34  * @test
  35  * @bug 8289422 8306088 8313720
  36  * @key randomness
  37  * @summary Auto-vectorization enhancement to support vector conditional move.
  38  * @library /test/lib /
  39  * @run driver ${test.main.class}
  40  */
  41 
  42 public class TestConditionalMove {
  43     final private static int SIZE = 1024;
  44     private static final Random RANDOM = Utils.getRandomInstance();
  45 
  46     public static void main(String[] args) {
  47         // Vectorizaion: +UseCMoveUnconditionally, +UseVectorCmov
  48         // Cross-product: +-AlignVector and +-UseCompactObjectHeaders
  49         TestFramework.runWithFlags("-XX:+UseCMoveUnconditionally", "-XX:+UseVectorCmov",
  50                                    "-XX:-UseCompactObjectHeaders", "-XX:-AlignVector");
  51         TestFramework.runWithFlags("-XX:+UseCMoveUnconditionally", "-XX:+UseVectorCmov",
  52                                    "-XX:-UseCompactObjectHeaders", "-XX:+AlignVector");
  53         TestFramework.runWithFlags("-XX:+UseCMoveUnconditionally", "-XX:+UseVectorCmov",
  54                                    "-XX:+UseCompactObjectHeaders", "-XX:-AlignVector");
  55         TestFramework.runWithFlags("-XX:+UseCMoveUnconditionally", "-XX:+UseVectorCmov",
  56                                    "-XX:+UseCompactObjectHeaders", "-XX:+AlignVector");
  57 
  58         // Scalar: +UseCMoveUnconditionally, -UseVectorCmov
  59         TestFramework.runWithFlags("-XX:+UseCMoveUnconditionally", "-XX:-UseVectorCmov",
  60                                    "-XX:+UnlockExperimentalVMOptions", "-XX:-UseCompactObjectHeaders");
  61         TestFramework.runWithFlags("-XX:+UseCMoveUnconditionally", "-XX:-UseVectorCmov",
  62                                    "-XX:+UnlockExperimentalVMOptions", "-XX:+UseCompactObjectHeaders");
  63     }
  64 
  65     // Compare 2 values, and pick one of them
  66     private float cmoveFloatGT(float a, float b) {
  67         return (a > b) ? a : b;
  68     }
  69 
  70     private float cmoveFloatGTSwap(float a, float b) {
  71         return (b > a) ? a : b;
  72     }
  73 
  74     private float cmoveFloatLT(float a, float b) {
  75         return (a < b) ? a : b;
  76     }
  77 
  78     private float cmoveFloatLTSwap(float a, float b) {
  79         return (b < a) ? a : b;
  80     }
  81 
  82     private float cmoveFloatEQ(float a, float b) {
  83         return (a == b) ? a : b;
  84     }
  85 
  86     private double cmoveDoubleLE(double a, double b) {
  87         return (a <= b) ? a : b;
  88     }
  89 
  90     private double cmoveDoubleLESwap(double a, double b) {
  91         return (b <= a) ? a : b;
  92     }
  93 
  94     private double cmoveDoubleGE(double a, double b) {
  95         return (a >= b) ? a : b;
  96     }
  97 
  98     private double cmoveDoubleGESwap(double a, double b) {
  99         return (b >= a) ? a : b;
 100     }
 101 
 102     private double cmoveDoubleNE(double a, double b) {
 103         return (a != b) ? a : b;
 104     }
 105 
 106     // Extensions: compare 2 values, and pick from 2 consts
 107     private float cmoveFGTforFConst(float a, float b) {
 108         return (a > b) ? 0.1f : -0.1f;
 109     }
 110 
 111     private float cmoveFGEforFConst(float a, float b) {
 112         return (a >= b) ? 0.1f : -0.1f;
 113     }
 114 
 115     private float cmoveFLTforFConst(float a, float b) {
 116         return (a < b) ? 0.1f : -0.1f;
 117     }
 118 
 119     private float cmoveFLEforFConst(float a, float b) {
 120         return (a <= b) ? 0.1f : -0.1f;
 121     }
 122 
 123     private float cmoveFEQforFConst(float a, float b) {
 124         return (a == b) ? 0.1f : -0.1f;
 125     }
 126 
 127     private float cmoveFNEQforFConst(float a, float b) {
 128         return (a != b) ? 0.1f : -0.1f;
 129     }
 130 
 131     private double cmoveDGTforDConst(double a, double b) {
 132         return (a > b) ? 0.1 : -0.1;
 133     }
 134 
 135     private double cmoveDGEforDConst(double a, double b) {
 136         return (a >= b) ? 0.1 : -0.1;
 137     }
 138 
 139     private double cmoveDLTforDConst(double a, double b) {
 140         return (a < b) ? 0.1 : -0.1;
 141     }
 142 
 143     private double cmoveDLEforDConst(double a, double b) {
 144         return (a <= b) ? 0.1 : -0.1;
 145     }
 146 
 147     private double cmoveDEQforDConst(double a, double b) {
 148         return (a == b) ? 0.1 : -0.1;
 149     }
 150 
 151     private double cmoveDNEQforDConst(double a, double b) {
 152         return (a != b) ? 0.1 : -0.1;
 153     }
 154 
 155     // Extension: Compare 2 ILFD values, and pick from 2 ILFD values
 156     // Signed comparison: I/L
 157     //    I for I
 158     private int cmoveIEQforI(int a, int b, int c, int d) {
 159         return (a == b) ? c : d;
 160     }
 161 
 162     private int cmoveINEforI(int a, int b, int c, int d) {
 163         return (a != b) ? c : d;
 164     }
 165 
 166     private int cmoveIGTforI(int a, int b, int c, int d) {
 167         return (a > b) ? c : d;
 168     }
 169 
 170     private int cmoveIGEforI(int a, int b, int c, int d) {
 171         return (a >= b) ? c : d;
 172     }
 173 
 174     private int cmoveILTforI(int a, int b, int c, int d) {
 175         return (a < b) ? c : d;
 176     }
 177 
 178     private int cmoveILEforI(int a, int b, int c, int d) {
 179         return (a <= b) ? c : d;
 180     }
 181 
 182     //    I for L
 183     private long cmoveIEQforL(int a, int b, long c, long d) {
 184         return (a == b) ? c : d;
 185     }
 186 
 187     private long cmoveINEforL(int a, int b, long c, long d) {
 188         return (a != b) ? c : d;
 189     }
 190 
 191     private long cmoveIGTforL(int a, int b, long c, long d) {
 192         return (a > b) ? c : d;
 193     }
 194 
 195     private long cmoveIGEforL(int a, int b, long c, long d) {
 196         return (a >= b) ? c : d;
 197     }
 198 
 199     private long cmoveILTforL(int a, int b, long c, long d) {
 200         return (a < b) ? c : d;
 201     }
 202 
 203     private long cmoveILEforL(int a, int b, long c, long d) {
 204         return (a <= b) ? c : d;
 205     }
 206 
 207     //    I for F
 208     private float cmoveIEQforF(int a, int b, float c, float d) {
 209         return (a == b) ? c : d;
 210     }
 211 
 212     private float cmoveINEforF(int a, int b, float c, float d) {
 213         return (a != b) ? c : d;
 214     }
 215 
 216     private float cmoveIGTforF(int a, int b, float c, float d) {
 217         return (a > b) ? c : d;
 218     }
 219 
 220     private float cmoveIGEforF(int a, int b, float c, float d) {
 221         return (a >= b) ? c : d;
 222     }
 223 
 224     private float cmoveILTforF(int a, int b, float c, float d) {
 225         return (a < b) ? c : d;
 226     }
 227 
 228     private float cmoveILEforF(int a, int b, float c, float d) {
 229         return (a <= b) ? c : d;
 230     }
 231 
 232     //    I for D
 233     private double cmoveIEQforD(int a, int b, double c, double d) {
 234         return (a == b) ? c : d;
 235     }
 236 
 237     private double cmoveINEforD(int a, int b, double c, double d) {
 238         return (a != b) ? c : d;
 239     }
 240 
 241     private double cmoveIGTforD(int a, int b, double c, double d) {
 242         return (a > b) ? c : d;
 243     }
 244 
 245     private double cmoveIGEforD(int a, int b, double c, double d) {
 246         return (a >= b) ? c : d;
 247     }
 248 
 249     private double cmoveILTforD(int a, int b, double c, double d) {
 250         return (a < b) ? c : d;
 251     }
 252 
 253     private double cmoveILEforD(int a, int b, double c, double d) {
 254         return (a <= b) ? c : d;
 255     }
 256 
 257     //    L for I
 258     private int cmoveLEQforI(long a, long b, int c, int d) {
 259         return (a == b) ? c : d;
 260     }
 261 
 262     private int cmoveLNEforI(long a, long b, int c, int d) {
 263         return (a != b) ? c : d;
 264     }
 265 
 266     private int cmoveLGTforI(long a, long b, int c, int d) {
 267         return (a > b) ? c : d;
 268     }
 269 
 270     private int cmoveLGEforI(long a, long b, int c, int d) {
 271         return (a >= b) ? c : d;
 272     }
 273 
 274     private int cmoveLLTforI(long a, long b, int c, int d) {
 275         return (a < b) ? c : d;
 276     }
 277 
 278     private int cmoveLLEforI(long a, long b, int c, int d) {
 279         return (a <= b) ? c : d;
 280     }
 281 
 282     //    L for L
 283     private long cmoveLEQforL(long a, long b, long c, long d) {
 284         return (a == b) ? c : d;
 285     }
 286 
 287     private long cmoveLNEforL(long a, long b, long c, long d) {
 288         return (a != b) ? c : d;
 289     }
 290 
 291     private long cmoveLGTforL(long a, long b, long c, long d) {
 292         return (a > b) ? c : d;
 293     }
 294 
 295     private long cmoveLGEforL(long a, long b, long c, long d) {
 296         return (a >= b) ? c : d;
 297     }
 298 
 299     private long cmoveLLTforL(long a, long b, long c, long d) {
 300         return (a < b) ? c : d;
 301     }
 302 
 303     private long cmoveLLEforL(long a, long b, long c, long d) {
 304         return (a <= b) ? c : d;
 305     }
 306 
 307     //    L for F
 308     private float cmoveLEQforF(long a, long b, float c, float d) {
 309         return (a == b) ? c : d;
 310     }
 311 
 312     private float cmoveLNEforF(long a, long b, float c, float d) {
 313         return (a != b) ? c : d;
 314     }
 315 
 316     private float cmoveLGTforF(long a, long b, float c, float d) {
 317         return (a > b) ? c : d;
 318     }
 319 
 320     private float cmoveLGEforF(long a, long b, float c, float d) {
 321         return (a >= b) ? c : d;
 322     }
 323 
 324     private float cmoveLLTforF(long a, long b, float c, float d) {
 325         return (a < b) ? c : d;
 326     }
 327 
 328     private float cmoveLLEforF(long a, long b, float c, float d) {
 329         return (a <= b) ? c : d;
 330     }
 331 
 332     //    L for D
 333     private double cmoveLEQforD(long a, long b, double c, double d) {
 334         return (a == b) ? c : d;
 335     }
 336 
 337     private double cmoveLNEforD(long a, long b, double c, double d) {
 338         return (a != b) ? c : d;
 339     }
 340 
 341     private double cmoveLGTforD(long a, long b, double c, double d) {
 342         return (a > b) ? c : d;
 343     }
 344 
 345     private double cmoveLGEforD(long a, long b, double c, double d) {
 346         return (a >= b) ? c : d;
 347     }
 348 
 349     private double cmoveLLTforD(long a, long b, double c, double d) {
 350         return (a < b) ? c : d;
 351     }
 352 
 353     private double cmoveLLEforD(long a, long b, double c, double d) {
 354         return (a <= b) ? c : d;
 355     }
 356 
 357     // Unsigned comparison: I/L
 358     //    I for I
 359     private int cmoveUIEQforI(int a, int b, int c, int d) {
 360         return Integer.compareUnsigned(a, b) == 0 ? c : d;
 361     }
 362 
 363     private int cmoveUINEforI(int a, int b, int c, int d) {
 364         return Integer.compareUnsigned(a, b) != 0 ? c : d;
 365     }
 366 
 367     private int cmoveUIGTforI(int a, int b, int c, int d) {
 368         return Integer.compareUnsigned(a, b) > 0 ? c : d;
 369     }
 370 
 371     private int cmoveUIGEforI(int a, int b, int c, int d) {
 372         return Integer.compareUnsigned(a, b) >= 0 ? c : d;
 373     }
 374 
 375     private int cmoveUILTforI(int a, int b, int c, int d) {
 376         return Integer.compareUnsigned(a, b) < 0 ? c : d;
 377     }
 378 
 379     private int cmoveUILEforI(int a, int b, int c, int d) {
 380         return Integer.compareUnsigned(a, b) <= 0 ? c : d;
 381     }
 382 
 383     //    I for L
 384     private long cmoveUIEQforL(int a, int b, long c, long d) {
 385         return Integer.compareUnsigned(a, b) == 0 ? c : d;
 386     }
 387 
 388     private long cmoveUINEforL(int a, int b, long c, long d) {
 389         return Integer.compareUnsigned(a, b) != 0 ? c : d;
 390     }
 391 
 392     private long cmoveUIGTforL(int a, int b, long c, long d) {
 393         return Integer.compareUnsigned(a, b) > 0 ? c : d;
 394     }
 395 
 396     private long cmoveUIGEforL(int a, int b, long c, long d) {
 397         return Integer.compareUnsigned(a, b) >= 0 ? c : d;
 398     }
 399 
 400     private long cmoveUILTforL(int a, int b, long c, long d) {
 401         return Integer.compareUnsigned(a, b) < 0 ? c : d;
 402     }
 403 
 404     private long cmoveUILEforL(int a, int b, long c, long d) {
 405         return Integer.compareUnsigned(a, b) <= 0 ? c : d;
 406     }
 407 
 408     //    I for F
 409     private float cmoveUIEQforF(int a, int b, float c, float d) {
 410         return Integer.compareUnsigned(a, b) == 0 ? c : d;
 411     }
 412 
 413     private float cmoveUINEforF(int a, int b, float c, float d) {
 414         return Integer.compareUnsigned(a, b) != 0 ? c : d;
 415     }
 416 
 417     private float cmoveUIGTforF(int a, int b, float c, float d) {
 418         return Integer.compareUnsigned(a, b) > 0 ? c : d;
 419     }
 420 
 421     private float cmoveUIGEforF(int a, int b, float c, float d) {
 422         return Integer.compareUnsigned(a, b) >= 0 ? c : d;
 423     }
 424 
 425     private float cmoveUILTforF(int a, int b, float c, float d) {
 426         return Integer.compareUnsigned(a, b) < 0 ? c : d;
 427     }
 428 
 429     private float cmoveUILEforF(int a, int b, float c, float d) {
 430         return Integer.compareUnsigned(a, b) <= 0 ? c : d;
 431     }
 432 
 433     //    I for D
 434     private double cmoveUIEQforD(int a, int b, double c, double d) {
 435         return Integer.compareUnsigned(a, b) == 0 ? c : d;
 436     }
 437 
 438     private double cmoveUINEforD(int a, int b, double c, double d) {
 439         return Integer.compareUnsigned(a, b) != 0 ? c : d;
 440     }
 441 
 442     private double cmoveUIGTforD(int a, int b, double c, double d) {
 443         return Integer.compareUnsigned(a, b) > 0 ? c : d;
 444     }
 445 
 446     private double cmoveUIGEforD(int a, int b, double c, double d) {
 447         return Integer.compareUnsigned(a, b) >= 0 ? c : d;
 448     }
 449 
 450     private double cmoveUILTforD(int a, int b, double c, double d) {
 451         return Integer.compareUnsigned(a, b) < 0 ? c : d;
 452     }
 453 
 454     private double cmoveUILEforD(int a, int b, double c, double d) {
 455         return Integer.compareUnsigned(a, b) <= 0 ? c : d;
 456     }
 457 
 458     //    L for I
 459     private int cmoveULEQforI(long a, long b, int c, int d) {
 460         return Long.compareUnsigned(a, b) == 0 ? c : d;
 461     }
 462 
 463     private int cmoveULNEforI(long a, long b, int c, int d) {
 464         return Long.compareUnsigned(a, b) != 0 ? c : d;
 465     }
 466 
 467     private int cmoveULGTforI(long a, long b, int c, int d) {
 468         return Long.compareUnsigned(a, b) > 0 ? c : d;
 469     }
 470 
 471     private int cmoveULGEforI(long a, long b, int c, int d) {
 472         return Long.compareUnsigned(a, b) >= 0 ? c : d;
 473     }
 474 
 475     private int cmoveULLTforI(long a, long b, int c, int d) {
 476         return Long.compareUnsigned(a, b) < 0 ? c : d;
 477     }
 478 
 479     private int cmoveULLEforI(long a, long b, int c, int d) {
 480         return Long.compareUnsigned(a, b) <= 0 ? c : d;
 481     }
 482 
 483     //    L for L
 484     private long cmoveULEQforL(long a, long b, long c, long d) {
 485         return Long.compareUnsigned(a, b) == 0 ? c : d;
 486     }
 487 
 488     private long cmoveULNEforL(long a, long b, long c, long d) {
 489         return Long.compareUnsigned(a, b) != 0 ? c : d;
 490     }
 491 
 492     private long cmoveULGTforL(long a, long b, long c, long d) {
 493         return Long.compareUnsigned(a, b) > 0 ? c : d;
 494     }
 495 
 496     private long cmoveULGEforL(long a, long b, long c, long d) {
 497         return Long.compareUnsigned(a, b) >= 0 ? c : d;
 498     }
 499 
 500     private long cmoveULLTforL(long a, long b, long c, long d) {
 501         return Long.compareUnsigned(a, b) < 0 ? c : d;
 502     }
 503 
 504     private long cmoveULLEforL(long a, long b, long c, long d) {
 505         return Long.compareUnsigned(a, b) <= 0 ? c : d;
 506     }
 507 
 508     //    L for F
 509     private float cmoveULEQforF(long a, long b, float c, float d) {
 510         return Long.compareUnsigned(a, b) == 0 ? c : d;
 511     }
 512 
 513     private float cmoveULNEforF(long a, long b, float c, float d) {
 514         return Long.compareUnsigned(a, b) != 0 ? c : d;
 515     }
 516 
 517     private float cmoveULGTforF(long a, long b, float c, float d) {
 518         return Long.compareUnsigned(a, b) > 0 ? c : d;
 519     }
 520 
 521     private float cmoveULGEforF(long a, long b, float c, float d) {
 522         return Long.compareUnsigned(a, b) >= 0 ? c : d;
 523     }
 524 
 525     private float cmoveULLTforF(long a, long b, float c, float d) {
 526         return Long.compareUnsigned(a, b) < 0 ? c : d;
 527     }
 528 
 529     private float cmoveULLEforF(long a, long b, float c, float d) {
 530         return Long.compareUnsigned(a, b) <= 0 ? c : d;
 531     }
 532 
 533     //    L for D
 534     private double cmoveULEQforD(long a, long b, double c, double d) {
 535         return Long.compareUnsigned(a, b) == 0 ? c : d;
 536     }
 537 
 538     private double cmoveULNEforD(long a, long b, double c, double d) {
 539         return Long.compareUnsigned(a, b) != 0 ? c : d;
 540     }
 541 
 542     private double cmoveULGTforD(long a, long b, double c, double d) {
 543         return Long.compareUnsigned(a, b) > 0 ? c : d;
 544     }
 545 
 546     private double cmoveULGEforD(long a, long b, double c, double d) {
 547         return Long.compareUnsigned(a, b) >= 0 ? c : d;
 548     }
 549 
 550     private double cmoveULLTforD(long a, long b, double c, double d) {
 551         return Long.compareUnsigned(a, b) < 0 ? c : d;
 552     }
 553 
 554     private double cmoveULLEforD(long a, long b, double c, double d) {
 555         return Long.compareUnsigned(a, b) <= 0 ? c : d;
 556     }
 557 
 558     // Float comparison
 559     private int cmoveFGTforI(float a, float b, int c, int d) {
 560         return (a > b) ? c : d;
 561     }
 562 
 563     private long cmoveFGTforL(float a, float b, long c, long d) {
 564         return (a > b) ? c : d;
 565     }
 566 
 567     private float cmoveFGTforF(float a, float b, float c, float d) {
 568         return (a > b) ? c : d;
 569     }
 570 
 571     private double cmoveFGTforD(float a, float b, double c, double d) {
 572         return (a > b) ? c : d;
 573     }
 574 
 575     // Double comparison
 576     private int cmoveDGTforI(double a, double b, int c, int d) {
 577         return (a > b) ? c : d;
 578     }
 579 
 580     private long cmoveDGTforL(double a, double b, long c, long d) {
 581         return (a > b) ? c : d;
 582     }
 583 
 584     private float cmoveDGTforF(double a, double b, float c, float d) {
 585         return (a > b) ? c : d;
 586     }
 587 
 588     private double cmoveDGTforD(double a, double b, double c, double d) {
 589         return (a > b) ? c : d;
 590     }
 591 
 592     // Compare 2 values, and pick one of them
 593     @Test
 594     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 595                   IRNode.VECTOR_MASK_CMP_F, ">0",
 596                   IRNode.VECTOR_BLEND_F, ">0",
 597                   IRNode.STORE_VECTOR, ">0"},
 598         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 599         applyIf = {"UseVectorCmov", "true"})
 600     @IR(failOn = {IRNode.STORE_VECTOR},
 601         applyIf = {"UseVectorCmov", "false"})
 602     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 603         applyIf = {"UseVectorCmov", "false"},
 604         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 605     private static void testCMoveVFGT(float[] a, float[] b, float[] c) {
 606         for (int i = 0; i < a.length; i++) {
 607             c[i] = (a[i] > b[i]) ? a[i] : b[i];
 608         }
 609     }
 610 
 611     @Test
 612     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 613                   IRNode.VECTOR_MASK_CMP_F, ">0",
 614                   IRNode.VECTOR_BLEND_F, ">0",
 615                   IRNode.STORE_VECTOR, ">0"},
 616         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 617         applyIf = {"UseVectorCmov", "true"})
 618     @IR(failOn = {IRNode.STORE_VECTOR},
 619         applyIf = {"UseVectorCmov", "false"})
 620     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 621         applyIf = {"UseVectorCmov", "false"},
 622         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 623     private static void testCMoveVFGTSwap(float[] a, float[] b, float[] c) {
 624         for (int i = 0; i < a.length; i++) {
 625             c[i] = (b[i] > a[i]) ? a[i] : b[i];
 626         }
 627     }
 628 
 629     @Test
 630     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 631                   IRNode.VECTOR_MASK_CMP_F, ">0",
 632                   IRNode.VECTOR_BLEND_F, ">0",
 633                   IRNode.STORE_VECTOR, ">0"},
 634         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 635         applyIf = {"UseVectorCmov", "true"})
 636     @IR(failOn = {IRNode.STORE_VECTOR},
 637         applyIf = {"UseVectorCmov", "false"})
 638     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 639         applyIf = {"UseVectorCmov", "false"},
 640         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 641     private static void testCMoveVFLT(float[] a, float[] b, float[] c) {
 642         for (int i = 0; i < a.length; i++) {
 643             c[i] = (a[i] < b[i]) ? a[i] : b[i];
 644         }
 645     }
 646 
 647     @Test
 648     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 649                   IRNode.VECTOR_MASK_CMP_F, ">0",
 650                   IRNode.VECTOR_BLEND_F, ">0",
 651                   IRNode.STORE_VECTOR, ">0"},
 652         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 653         applyIf = {"UseVectorCmov", "true"})
 654     @IR(failOn = {IRNode.STORE_VECTOR},
 655         applyIf = {"UseVectorCmov", "false"})
 656     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 657         applyIf = {"UseVectorCmov", "false"},
 658         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 659     private static void testCMoveVFLTSwap(float[] a, float[] b, float[] c) {
 660         for (int i = 0; i < a.length; i++) {
 661             c[i] = (b[i] < a[i]) ? a[i] : b[i];
 662         }
 663     }
 664 
 665     @Test
 666     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 667                   IRNode.VECTOR_MASK_CMP_F, ">0",
 668                   IRNode.VECTOR_BLEND_F, ">0",
 669                   IRNode.STORE_VECTOR, ">0"},
 670         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 671         applyIf = {"UseVectorCmov", "true"})
 672     @IR(failOn = {IRNode.STORE_VECTOR},
 673         applyIf = {"UseVectorCmov", "false"})
 674     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 675         applyIf = {"UseVectorCmov", "false"},
 676         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 677     private static void testCMoveVFEQ(float[] a, float[] b, float[] c) {
 678         for (int i = 0; i < a.length; i++) {
 679             c[i] = (a[i] == b[i]) ? a[i] : b[i];
 680         }
 681     }
 682 
 683     @Test
 684     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
 685                   IRNode.VECTOR_MASK_CMP_D, ">0",
 686                   IRNode.VECTOR_BLEND_D, ">0",
 687                   IRNode.STORE_VECTOR, ">0"},
 688         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 689         applyIf = {"UseVectorCmov", "true"})
 690     @IR(failOn = {IRNode.STORE_VECTOR},
 691         applyIf = {"UseVectorCmov", "false"})
 692     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
 693         applyIf = {"UseVectorCmov", "false"},
 694         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 695     private static void testCMoveVDLE(double[] a, double[] b, double[] c) {
 696         for (int i = 0; i < a.length; i++) {
 697             c[i] = (a[i] <= b[i]) ? a[i] : b[i];
 698         }
 699     }
 700 
 701     @Test
 702     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
 703                   IRNode.VECTOR_MASK_CMP_D, ">0",
 704                   IRNode.VECTOR_BLEND_D, ">0",
 705                   IRNode.STORE_VECTOR, ">0"},
 706         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 707         applyIf = {"UseVectorCmov", "true"})
 708     @IR(failOn = {IRNode.STORE_VECTOR},
 709         applyIf = {"UseVectorCmov", "false"})
 710     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
 711         applyIf = {"UseVectorCmov", "false"},
 712         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 713     private static void testCMoveVDLESwap(double[] a, double[] b, double[] c) {
 714         for (int i = 0; i < a.length; i++) {
 715             c[i] = (b[i] <= a[i]) ? a[i] : b[i];
 716         }
 717     }
 718 
 719     @Test
 720     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
 721                   IRNode.VECTOR_MASK_CMP_D, ">0",
 722                   IRNode.VECTOR_BLEND_D, ">0",
 723                   IRNode.STORE_VECTOR, ">0"},
 724         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 725         applyIf = {"UseVectorCmov", "true"})
 726     @IR(failOn = {IRNode.STORE_VECTOR},
 727         applyIf = {"UseVectorCmov", "false"})
 728     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
 729         applyIf = {"UseVectorCmov", "false"},
 730         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 731     private static void testCMoveVDGE(double[] a, double[] b, double[] c) {
 732         for (int i = 0; i < a.length; i++) {
 733             c[i] = (a[i] >= b[i]) ? a[i] : b[i];
 734         }
 735     }
 736 
 737     @Test
 738     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
 739                   IRNode.VECTOR_MASK_CMP_D, ">0",
 740                   IRNode.VECTOR_BLEND_D, ">0",
 741                   IRNode.STORE_VECTOR, ">0"},
 742         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 743         applyIf = {"UseVectorCmov", "true"})
 744     @IR(failOn = {IRNode.STORE_VECTOR},
 745         applyIf = {"UseVectorCmov", "false"})
 746     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
 747         applyIf = {"UseVectorCmov", "false"},
 748         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 749     private static void testCMoveVDGESwap(double[] a, double[] b, double[] c) {
 750         for (int i = 0; i < a.length; i++) {
 751             c[i] = (b[i] >= a[i]) ? a[i] : b[i];
 752         }
 753     }
 754 
 755     @Test
 756     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
 757                   IRNode.VECTOR_MASK_CMP_D, ">0",
 758                   IRNode.VECTOR_BLEND_D, ">0",
 759                   IRNode.STORE_VECTOR, ">0"},
 760         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 761         applyIf = {"UseVectorCmov", "true"})
 762     @IR(failOn = {IRNode.STORE_VECTOR},
 763         applyIf = {"UseVectorCmov", "false"})
 764     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
 765         applyIf = {"UseVectorCmov", "false"},
 766         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 767     private static void testCMoveVDNE(double[] a, double[] b, double[] c) {
 768         for (int i = 0; i < a.length; i++) {
 769             c[i] = (a[i] != b[i]) ? a[i] : b[i];
 770         }
 771     }
 772 
 773     // Extensions: compare 2 values, and pick from 2 consts
 774     @Test
 775     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 776                   IRNode.VECTOR_MASK_CMP_F, ">0",
 777                   IRNode.VECTOR_BLEND_F, ">0",
 778                   IRNode.STORE_VECTOR, ">0"},
 779         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 780         applyIf = {"UseVectorCmov", "true"})
 781     @IR(failOn = {IRNode.STORE_VECTOR},
 782         applyIf = {"UseVectorCmov", "false"})
 783     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 784         applyIf = {"UseVectorCmov", "false"},
 785         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 786     private static void testCMoveFGTforFConst(float[] a, float[] b, float[] c) {
 787         for (int i = 0; i < a.length; i++) {
 788             c[i] = (a[i] > b[i]) ? 0.1f : -0.1f;
 789         }
 790     }
 791 
 792     @Test
 793     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 794                   IRNode.VECTOR_MASK_CMP_F, ">0",
 795                   IRNode.VECTOR_BLEND_F, ">0",
 796                   IRNode.STORE_VECTOR, ">0"},
 797         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 798         applyIf = {"UseVectorCmov", "true"})
 799     @IR(failOn = {IRNode.STORE_VECTOR},
 800         applyIf = {"UseVectorCmov", "false"})
 801     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 802         applyIf = {"UseVectorCmov", "false"},
 803         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 804     private static void testCMoveFGEforFConst(float[] a, float[] b, float[] c) {
 805         for (int i = 0; i < a.length; i++) {
 806             c[i] = (a[i] >= b[i]) ? 0.1f : -0.1f;
 807         }
 808     }
 809 
 810     @Test
 811     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 812                   IRNode.VECTOR_MASK_CMP_F, ">0",
 813                   IRNode.VECTOR_BLEND_F, ">0",
 814                   IRNode.STORE_VECTOR, ">0"},
 815         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 816         applyIf = {"UseVectorCmov", "true"})
 817     @IR(failOn = {IRNode.STORE_VECTOR},
 818         applyIf = {"UseVectorCmov", "false"})
 819     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 820         applyIf = {"UseVectorCmov", "false"},
 821         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 822     private static void testCMoveFLTforFConst(float[] a, float[] b, float[] c) {
 823         for (int i = 0; i < a.length; i++) {
 824             c[i] = (a[i] < b[i]) ? 0.1f : -0.1f;
 825         }
 826     }
 827 
 828     @Test
 829     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 830                   IRNode.VECTOR_MASK_CMP_F, ">0",
 831                   IRNode.VECTOR_BLEND_F, ">0",
 832                   IRNode.STORE_VECTOR, ">0"},
 833         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 834         applyIf = {"UseVectorCmov", "true"})
 835     @IR(failOn = {IRNode.STORE_VECTOR},
 836         applyIf = {"UseVectorCmov", "false"})
 837     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 838         applyIf = {"UseVectorCmov", "false"},
 839         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 840     private static void testCMoveFLEforFConst(float[] a, float[] b, float[] c) {
 841         for (int i = 0; i < a.length; i++) {
 842             c[i] = (a[i] <= b[i]) ? 0.1f : -0.1f;
 843         }
 844     }
 845 
 846     @Test
 847     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 848                   IRNode.VECTOR_MASK_CMP_F, ">0",
 849                   IRNode.VECTOR_BLEND_F, ">0",
 850                   IRNode.STORE_VECTOR, ">0"},
 851         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 852         applyIf = {"UseVectorCmov", "true"})
 853     @IR(failOn = {IRNode.STORE_VECTOR},
 854         applyIf = {"UseVectorCmov", "false"})
 855     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 856         applyIf = {"UseVectorCmov", "false"},
 857         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 858     private static void testCMoveFEQforFConst(float[] a, float[] b, float[] c) {
 859         for (int i = 0; i < a.length; i++) {
 860             c[i] = (a[i] == b[i]) ? 0.1f : -0.1f;
 861         }
 862     }
 863 
 864     @Test
 865     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 866                   IRNode.VECTOR_MASK_CMP_F, ">0",
 867                   IRNode.VECTOR_BLEND_F, ">0",
 868                   IRNode.STORE_VECTOR, ">0"},
 869         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 870         applyIf = {"UseVectorCmov", "true"})
 871     @IR(failOn = {IRNode.STORE_VECTOR},
 872         applyIf = {"UseVectorCmov", "false"})
 873     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 874         applyIf = {"UseVectorCmov", "false"},
 875         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 876     private static void testCMoveFNEQforFConst(float[] a, float[] b, float[] c) {
 877         for (int i = 0; i < a.length; i++) {
 878             c[i] = (a[i] != b[i]) ? 0.1f : -0.1f;
 879         }
 880     }
 881 
 882     @Test
 883     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 884                   IRNode.VECTOR_MASK_CMP_F, ">0",
 885                   IRNode.VECTOR_BLEND_F, ">0",
 886                   IRNode.STORE_VECTOR, ">0"},
 887         applyIfAnd = {"UseCompactObjectHeaders", "false", "UseVectorCmov", "true"},
 888         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"})
 889     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 890                     IRNode.VECTOR_MASK_CMP_F, ">0",
 891                     IRNode.VECTOR_BLEND_F, ">0",
 892                     IRNode.STORE_VECTOR, ">0"},
 893         applyIfAnd = {"AlignVector", "false", "UseVectorCmov", "true"},
 894         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"})
 895     @IR(failOn = {IRNode.STORE_VECTOR},
 896         applyIf = {"UseVectorCmov", "false"})
 897     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 898         applyIf = {"UseVectorCmov", "false"},
 899         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 900     private static void testCMoveFLTforFConstH2(float[] a, float[] b, float[] c) {
 901         for (int i = 0; i < a.length; i+=2) {
 902             c[i+0] = (a[i+0] < b[i+0]) ? 0.1f : -0.1f;
 903             c[i+1] = (a[i+1] < b[i+1]) ? 0.1f : -0.1f;
 904             // With AlignVector, we need 8-byte alignment of vector loads/stores.
 905             // UseCompactObjectHeaders=false                        UseCompactObjectHeaders=true
 906             // adr = base + 16 + 8*i      ->  always                adr = base + 12 + 8*i      ->  never
 907             // -> vectorize                                         -> no vectorization
 908         }
 909     }
 910 
 911     @Test
 912     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 913                   IRNode.VECTOR_MASK_CMP_F, ">0",
 914                   IRNode.VECTOR_BLEND_F, ">0",
 915                   IRNode.STORE_VECTOR, ">0"},
 916         applyIfAnd = {"UseCompactObjectHeaders", "false", "UseVectorCmov", "true"},
 917         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"})
 918     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
 919                     IRNode.VECTOR_MASK_CMP_F, ">0",
 920                     IRNode.VECTOR_BLEND_F, ">0",
 921                     IRNode.STORE_VECTOR, ">0"},
 922         applyIfAnd = {"AlignVector", "false", "UseVectorCmov", "true"},
 923         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"})
 924     @IR(failOn = {IRNode.STORE_VECTOR},
 925         applyIf = {"UseVectorCmov", "false"})
 926     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 927         applyIf = {"UseVectorCmov", "false"},
 928         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 929     private static void testCMoveFLEforFConstH2(float[] a, float[] b, float[] c) {
 930         for (int i = 0; i < a.length; i+=2) {
 931             c[i+0] = (a[i+0] <= b[i+0]) ? 0.1f : -0.1f;
 932             c[i+1] = (a[i+1] <= b[i+1]) ? 0.1f : -0.1f;
 933             // With AlignVector, we need 8-byte alignment of vector loads/stores.
 934             // UseCompactObjectHeaders=false                        UseCompactObjectHeaders=true
 935             // adr = base + 16 + 8*i      ->  always                adr = base + 12 + 8*i      ->  never
 936             // -> vectorize                                         -> no vectorization
 937         }
 938     }
 939 
 940     @Test
 941     @IR(counts = {IRNode.LOAD_VECTOR_F, "=0",
 942                   IRNode.VECTOR_MASK_CMP_F, "=0",
 943                   IRNode.VECTOR_BLEND_F, "=0",
 944                   IRNode.STORE_VECTOR, "=0"},
 945         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 946         applyIf = {"UseVectorCmov", "true"})
 947     @IR(failOn = {IRNode.STORE_VECTOR},
 948         applyIf = {"UseVectorCmov", "false"})
 949     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 950         applyIf = {"UseVectorCmov", "false"},
 951         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 952     private static void testCMoveFYYforFConstH2(float[] a, float[] b, float[] c) {
 953         for (int i = 0; i < a.length; i+=2) {
 954             c[i+0] = (a[i+0] <= b[i+0]) ? 0.1f : -0.1f;
 955             c[i+1] = (a[i+1] <  b[i+1]) ? 0.1f : -0.1f;
 956         }
 957     }
 958 
 959     @Test
 960     @IR(counts = {IRNode.LOAD_VECTOR_F, "=0",
 961                   IRNode.VECTOR_MASK_CMP_F, "=0",
 962                   IRNode.VECTOR_BLEND_F, "=0",
 963                   IRNode.STORE_VECTOR, "=0"},
 964         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 965         applyIf = {"UseVectorCmov", "true"})
 966     @IR(failOn = {IRNode.STORE_VECTOR},
 967         applyIf = {"UseVectorCmov", "false"})
 968     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
 969         applyIf = {"UseVectorCmov", "false"},
 970         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 971     private static void testCMoveFXXforFConstH2(float[] a, float[] b, float[] c) {
 972         for (int i = 0; i < a.length; i+=2) {
 973             c[i+0] = (a[i+0] <  b[i+0]) ? 0.1f : -0.1f;
 974             c[i+1] = (a[i+1] <= b[i+1]) ? 0.1f : -0.1f;
 975         }
 976     }
 977 
 978     @Test
 979     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
 980                   IRNode.VECTOR_MASK_CMP_D, ">0",
 981                   IRNode.VECTOR_BLEND_D, ">0",
 982                   IRNode.STORE_VECTOR, ">0"},
 983         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
 984         applyIf = {"UseVectorCmov", "true"})
 985     @IR(failOn = {IRNode.STORE_VECTOR},
 986         applyIf = {"UseVectorCmov", "false"})
 987     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
 988         applyIf = {"UseVectorCmov", "false"},
 989         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
 990     private static void testCMoveDGTforDConst(double[] a, double[] b, double[] c) {
 991         for (int i = 0; i < a.length; i++) {
 992             c[i] = (a[i] > b[i]) ? 0.1 : -0.1;
 993         }
 994     }
 995 
 996     @Test
 997     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
 998                   IRNode.VECTOR_MASK_CMP_D, ">0",
 999                   IRNode.VECTOR_BLEND_D, ">0",
1000                   IRNode.STORE_VECTOR, ">0"},
1001         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1002         applyIf = {"UseVectorCmov", "true"})
1003     @IR(failOn = {IRNode.STORE_VECTOR},
1004         applyIf = {"UseVectorCmov", "false"})
1005     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
1006         applyIf = {"UseVectorCmov", "false"},
1007         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1008     private static void testCMoveDGEforDConst(double[] a, double[] b, double[] c) {
1009         for (int i = 0; i < a.length; i++) {
1010             c[i] = (a[i] >= b[i]) ? 0.1 : -0.1;
1011         }
1012     }
1013 
1014     @Test
1015     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
1016                   IRNode.VECTOR_MASK_CMP_D, ">0",
1017                   IRNode.VECTOR_BLEND_D, ">0",
1018                   IRNode.STORE_VECTOR, ">0"},
1019         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1020         applyIf = {"UseVectorCmov", "true"})
1021     @IR(failOn = {IRNode.STORE_VECTOR},
1022         applyIf = {"UseVectorCmov", "false"})
1023     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
1024         applyIf = {"UseVectorCmov", "false"},
1025         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1026     private static void testCMoveDLTforDConst(double[] a, double[] b, double[] c) {
1027         for (int i = 0; i < a.length; i++) {
1028             c[i] = (a[i] < b[i]) ? 0.1 : -0.1;
1029         }
1030     }
1031 
1032     @Test
1033     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
1034                   IRNode.VECTOR_MASK_CMP_D, ">0",
1035                   IRNode.VECTOR_BLEND_D, ">0",
1036                   IRNode.STORE_VECTOR, ">0"},
1037         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1038         applyIf = {"UseVectorCmov", "true"})
1039     @IR(failOn = {IRNode.STORE_VECTOR},
1040         applyIf = {"UseVectorCmov", "false"})
1041     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
1042         applyIf = {"UseVectorCmov", "false"},
1043         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1044     private static void testCMoveDLEforDConst(double[] a, double[] b, double[] c) {
1045         for (int i = 0; i < a.length; i++) {
1046             c[i] = (a[i] <= b[i]) ? 0.1 : -0.1;
1047         }
1048     }
1049 
1050     @Test
1051     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
1052                   IRNode.VECTOR_MASK_CMP_D, ">0",
1053                   IRNode.VECTOR_BLEND_D, ">0",
1054                   IRNode.STORE_VECTOR, ">0"},
1055         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1056         applyIf = {"UseVectorCmov", "true"})
1057     @IR(failOn = {IRNode.STORE_VECTOR},
1058         applyIf = {"UseVectorCmov", "false"})
1059     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
1060         applyIf = {"UseVectorCmov", "false"},
1061         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1062     private static void testCMoveDEQforDConst(double[] a, double[] b, double[] c) {
1063         for (int i = 0; i < a.length; i++) {
1064             c[i] = (a[i] == b[i]) ? 0.1 : -0.1;
1065         }
1066     }
1067 
1068     @Test
1069     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
1070                   IRNode.VECTOR_MASK_CMP_D, ">0",
1071                   IRNode.VECTOR_BLEND_D, ">0",
1072                   IRNode.STORE_VECTOR, ">0"},
1073         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1074         applyIf = {"UseVectorCmov", "true"})
1075     @IR(failOn = {IRNode.STORE_VECTOR},
1076         applyIf = {"UseVectorCmov", "false"})
1077     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
1078         applyIf = {"UseVectorCmov", "false"},
1079         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1080     private static void testCMoveDNEQforDConst(double[] a, double[] b, double[] c) {
1081         for (int i = 0; i < a.length; i++) {
1082             c[i] = (a[i] != b[i]) ? 0.1 : -0.1;
1083         }
1084     }
1085 
1086     @Test
1087     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
1088                   IRNode.VECTOR_MASK_CMP_D, ">0",
1089                   IRNode.VECTOR_BLEND_D, ">0",
1090                   IRNode.STORE_VECTOR, ">0"},
1091         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1092         applyIf = {"UseVectorCmov", "true"})
1093     @IR(failOn = {IRNode.STORE_VECTOR},
1094         applyIf = {"UseVectorCmov", "false"})
1095     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
1096         applyIf = {"UseVectorCmov", "false"},
1097         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1098     private static void testCMoveDLTforDConstH2(double[] a, double[] b, double[] c) {
1099         for (int i = 0; i < a.length; i+=2) {
1100             c[i+0] = (a[i+0] < b[i+0]) ? 0.1 : -0.1;
1101             c[i+1] = (a[i+1] < b[i+1]) ? 0.1 : -0.1;
1102         }
1103     }
1104 
1105     @Test
1106     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
1107                   IRNode.VECTOR_MASK_CMP_D, ">0",
1108                   IRNode.VECTOR_BLEND_D, ">0",
1109                   IRNode.STORE_VECTOR, ">0"},
1110         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1111         applyIf = {"UseVectorCmov", "true"})
1112     @IR(failOn = {IRNode.STORE_VECTOR},
1113         applyIf = {"UseVectorCmov", "false"})
1114     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
1115         applyIf = {"UseVectorCmov", "false"},
1116         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1117     private static void testCMoveDLEforDConstH2(double[] a, double[] b, double[] c) {
1118         for (int i = 0; i < a.length; i+=2) {
1119             c[i+0] = (a[i+0] <= b[i+0]) ? 0.1 : -0.1;
1120             c[i+1] = (a[i+1] <= b[i+1]) ? 0.1 : -0.1;
1121         }
1122     }
1123 
1124     @Test
1125     @IR(counts = {IRNode.LOAD_VECTOR_D, "=0",
1126                   IRNode.VECTOR_MASK_CMP_D, "=0",
1127                   IRNode.VECTOR_BLEND_D, "=0",
1128                   IRNode.STORE_VECTOR, "=0"},
1129         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1130         applyIf = {"UseVectorCmov", "true"})
1131     @IR(failOn = {IRNode.STORE_VECTOR},
1132         applyIf = {"UseVectorCmov", "false"})
1133     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
1134         applyIf = {"UseVectorCmov", "false"},
1135         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1136     private static void testCMoveDYYforDConstH2(double[] a, double[] b, double[] c) {
1137         for (int i = 0; i < a.length; i+=2) {
1138             c[i+0] = (a[i+0] <= b[i+0]) ? 0.1 : -0.1;
1139             c[i+1] = (a[i+1] <  b[i+1]) ? 0.1 : -0.1;
1140         }
1141     }
1142 
1143     @Test
1144     @IR(counts = {IRNode.LOAD_VECTOR_D, "=0",
1145                   IRNode.VECTOR_MASK_CMP_D, "=0",
1146                   IRNode.VECTOR_BLEND_D, "=0",
1147                   IRNode.STORE_VECTOR, "=0"},
1148         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1149         applyIf = {"UseVectorCmov", "true"})
1150     @IR(failOn = {IRNode.STORE_VECTOR},
1151         applyIf = {"UseVectorCmov", "false"})
1152     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
1153         applyIf = {"UseVectorCmov", "false"},
1154         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1155     private static void testCMoveDXXforDConstH2(double[] a, double[] b, double[] c) {
1156         for (int i = 0; i < a.length; i+=2) {
1157             c[i+0] = (a[i+0] <  b[i+0]) ? 0.1 : -0.1;
1158             c[i+1] = (a[i+1] <= b[i+1]) ? 0.1 : -0.1;
1159         }
1160     }
1161 
1162     // Extension: Compare 2 ILFD values, and pick from 2 ILFD values
1163     // Note:
1164     //   To guarantee that CMove is introduced, I need to perform the loads before the branch. To ensure they
1165     //   do not float down into the branches, I compute a value, and store it to r2 (same as r, except that the
1166     //   compilation does not know that).
1167     //   So far, vectorization only works for CMoveF/D, with same data-width comparison (F/I for F, D/L for D).
1168     //   TODO: enable CMOVE_I/L verification when it's guaranteed to generate CMOVE_I/L, JDK-8371984.
1169     //
1170     // Signed comparison: I/L
1171     //     I fo I
1172     @Test
1173     @IR(failOn = {IRNode.STORE_VECTOR})
1174     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_I, ">0"},
1175     //     applyIf = {"UseVectorCmov", "false"},
1176     //     applyIfPlatform = {"riscv64", "true"})
1177     private static void testCMoveIEQforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
1178         for (int i = 0; i < a.length; i++) {
1179             int cc = c[i];
1180             int dd = d[i];
1181             r2[i] = cc + dd;
1182             r[i] = (a[i] == b[i]) ? cc : dd;
1183         }
1184     }
1185 
1186     @Test
1187     @IR(failOn = {IRNode.STORE_VECTOR})
1188     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_I, ">0"},
1189     //     applyIf = {"UseVectorCmov", "false"},
1190     //     applyIfPlatform = {"riscv64", "true"})
1191     private static void testCMoveINEforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
1192         for (int i = 0; i < a.length; i++) {
1193             int cc = c[i];
1194             int dd = d[i];
1195             r2[i] = cc + dd;
1196             r[i] = (a[i] != b[i]) ? cc : dd;
1197         }
1198     }
1199 
1200     @Test
1201     @IR(failOn = {IRNode.STORE_VECTOR})
1202     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_I, ">0"},
1203     //     applyIf = {"UseVectorCmov", "false"},
1204     //     applyIfPlatform = {"riscv64", "true"})
1205     private static void testCMoveIGTforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
1206         for (int i = 0; i < a.length; i++) {
1207             int cc = c[i];
1208             int dd = d[i];
1209             r2[i] = cc + dd;
1210             r[i] = (a[i] > b[i]) ? cc : dd;
1211         }
1212     }
1213 
1214     @Test
1215     @IR(failOn = {IRNode.STORE_VECTOR})
1216     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_I, ">0"},
1217     //     applyIf = {"UseVectorCmov", "false"},
1218     //     applyIfPlatform = {"riscv64", "true"})
1219     private static void testCMoveIGEforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
1220         for (int i = 0; i < a.length; i++) {
1221             int cc = c[i];
1222             int dd = d[i];
1223             r2[i] = cc + dd;
1224             r[i] = (a[i] >= b[i]) ? cc : dd;
1225         }
1226     }
1227 
1228     @Test
1229     @IR(failOn = {IRNode.STORE_VECTOR})
1230     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_I, ">0"},
1231     //     applyIf = {"UseVectorCmov", "false"},
1232     //     applyIfPlatform = {"riscv64", "true"})
1233     private static void testCMoveILTforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
1234         for (int i = 0; i < a.length; i++) {
1235             int cc = c[i];
1236             int dd = d[i];
1237             r2[i] = cc + dd;
1238             r[i] = (a[i] < b[i]) ? cc : dd;
1239         }
1240     }
1241 
1242     @Test
1243     @IR(failOn = {IRNode.STORE_VECTOR})
1244     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_I, ">0"},
1245     //     applyIf = {"UseVectorCmov", "false"},
1246     //     applyIfPlatform = {"riscv64", "true"})
1247     private static void testCMoveILEforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
1248         for (int i = 0; i < a.length; i++) {
1249             int cc = c[i];
1250             int dd = d[i];
1251             r2[i] = cc + dd;
1252             r[i] = (a[i] <= b[i]) ? cc : dd;
1253         }
1254     }
1255 
1256     //     I fo L
1257     @Test
1258     @IR(failOn = {IRNode.STORE_VECTOR})
1259     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_I, ">0"},
1260     //     applyIf = {"UseVectorCmov", "false"},
1261     //     applyIfPlatform = {"riscv64", "true"})
1262     private static void testCMoveIEQforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
1263         for (int i = 0; i < a.length; i++) {
1264             long cc = c[i];
1265             long dd = d[i];
1266             r2[i] = cc + dd;
1267             r[i] = (a[i] == b[i]) ? cc : dd;
1268         }
1269     }
1270 
1271     @Test
1272     @IR(failOn = {IRNode.STORE_VECTOR})
1273     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_I, ">0"},
1274     //     applyIf = {"UseVectorCmov", "false"},
1275     //     applyIfPlatform = {"riscv64", "true"})
1276     private static void testCMoveINEforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
1277         for (int i = 0; i < a.length; i++) {
1278             long cc = c[i];
1279             long dd = d[i];
1280             r2[i] = cc + dd;
1281             r[i] = (a[i] != b[i]) ? cc : dd;
1282         }
1283     }
1284 
1285     @Test
1286     @IR(failOn = {IRNode.STORE_VECTOR})
1287     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_I, ">0"},
1288     //     applyIf = {"UseVectorCmov", "false"},
1289     //     applyIfPlatform = {"riscv64", "true"})
1290     private static void testCMoveIGTforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
1291         for (int i = 0; i < a.length; i++) {
1292             long cc = c[i];
1293             long dd = d[i];
1294             r2[i] = cc + dd;
1295             r[i] = (a[i] > b[i]) ? cc : dd;
1296         }
1297     }
1298 
1299     @Test
1300     @IR(failOn = {IRNode.STORE_VECTOR})
1301     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_I, ">0"},
1302     //     applyIf = {"UseVectorCmov", "false"},
1303     //     applyIfPlatform = {"riscv64", "true"})
1304     private static void testCMoveIGEforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
1305         for (int i = 0; i < a.length; i++) {
1306             long cc = c[i];
1307             long dd = d[i];
1308             r2[i] = cc + dd;
1309             r[i] = (a[i] >= b[i]) ? cc : dd;
1310         }
1311     }
1312 
1313     @Test
1314     @IR(failOn = {IRNode.STORE_VECTOR})
1315     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_I, ">0"},
1316     //     applyIf = {"UseVectorCmov", "false"},
1317     //     applyIfPlatform = {"riscv64", "true"})
1318     private static void testCMoveILTforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
1319         for (int i = 0; i < a.length; i++) {
1320             long cc = c[i];
1321             long dd = d[i];
1322             r2[i] = cc + dd;
1323             r[i] = (a[i] < b[i]) ? cc : dd;
1324         }
1325     }
1326 
1327     @Test
1328     @IR(failOn = {IRNode.STORE_VECTOR})
1329     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_I, ">0"},
1330     //     applyIf = {"UseVectorCmov", "false"},
1331     //     applyIfPlatform = {"riscv64", "true"})
1332     private static void testCMoveILEforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
1333         for (int i = 0; i < a.length; i++) {
1334             long cc = c[i];
1335             long dd = d[i];
1336             r2[i] = cc + dd;
1337             r[i] = (a[i] <= b[i]) ? cc : dd;
1338         }
1339     }
1340 
1341     //     I fo F
1342     @Test
1343     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1344                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1345                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1346                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1347                   IRNode.STORE_VECTOR, ">0"},
1348         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1349         applyIf = {"UseVectorCmov", "true"})
1350     @IR(failOn = {IRNode.STORE_VECTOR},
1351         applyIf = {"UseVectorCmov", "false"})
1352     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_I, ">0"},
1353         applyIf = {"UseVectorCmov", "false"},
1354         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1355     private static void testCMoveIEQforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
1356         for (int i = 0; i < a.length; i++) {
1357             float cc = c[i];
1358             float dd = d[i];
1359             r2[i] = cc + dd;
1360             r[i] = (a[i] == b[i]) ? cc : dd;
1361         }
1362     }
1363 
1364     @Test
1365     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1366                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1367                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1368                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1369                   IRNode.STORE_VECTOR, ">0"},
1370         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1371         applyIf = {"UseVectorCmov", "true"})
1372     @IR(failOn = {IRNode.STORE_VECTOR},
1373         applyIf = {"UseVectorCmov", "false"})
1374     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_I, ">0"},
1375         applyIf = {"UseVectorCmov", "false"},
1376         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1377     private static void testCMoveINEforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
1378         for (int i = 0; i < a.length; i++) {
1379             float cc = c[i];
1380             float dd = d[i];
1381             r2[i] = cc + dd;
1382             r[i] = (a[i] != b[i]) ? cc : dd;
1383         }
1384     }
1385 
1386     @Test
1387     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1388                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1389                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1390                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1391                   IRNode.STORE_VECTOR, ">0"},
1392         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1393         applyIf = {"UseVectorCmov", "true"})
1394     @IR(failOn = {IRNode.STORE_VECTOR},
1395         applyIf = {"UseVectorCmov", "false"})
1396     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_I, ">0"},
1397         applyIf = {"UseVectorCmov", "false"},
1398         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1399     private static void testCMoveIGTforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
1400         for (int i = 0; i < a.length; i++) {
1401             float cc = c[i];
1402             float dd = d[i];
1403             r2[i] = cc + dd;
1404             r[i] = (a[i] > b[i]) ? cc : dd;
1405         }
1406     }
1407 
1408     @Test
1409     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1410                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1411                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1412                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1413                   IRNode.STORE_VECTOR, ">0"},
1414         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1415         applyIf = {"UseVectorCmov", "true"})
1416     @IR(failOn = {IRNode.STORE_VECTOR},
1417         applyIf = {"UseVectorCmov", "false"})
1418     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_I, ">0"},
1419         applyIf = {"UseVectorCmov", "false"},
1420         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1421     private static void testCMoveIGEforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
1422         for (int i = 0; i < a.length; i++) {
1423             float cc = c[i];
1424             float dd = d[i];
1425             r2[i] = cc + dd;
1426             r[i] = (a[i] >= b[i]) ? cc : dd;
1427         }
1428     }
1429 
1430     @Test
1431     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1432                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1433                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1434                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1435                   IRNode.STORE_VECTOR, ">0"},
1436         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1437         applyIf = {"UseVectorCmov", "true"})
1438     @IR(failOn = {IRNode.STORE_VECTOR},
1439         applyIf = {"UseVectorCmov", "false"})
1440     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_I, ">0"},
1441         applyIf = {"UseVectorCmov", "false"},
1442         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1443     private static void testCMoveILTforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
1444         for (int i = 0; i < a.length; i++) {
1445             float cc = c[i];
1446             float dd = d[i];
1447             r2[i] = cc + dd;
1448             r[i] = (a[i] < b[i]) ? cc : dd;
1449         }
1450     }
1451 
1452     @Test
1453     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1454                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1455                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1456                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
1457                   IRNode.STORE_VECTOR, ">0"},
1458         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
1459         applyIf = {"UseVectorCmov", "true"})
1460     @IR(failOn = {IRNode.STORE_VECTOR},
1461         applyIf = {"UseVectorCmov", "false"})
1462     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_I, ">0"},
1463         applyIf = {"UseVectorCmov", "false"},
1464         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1465     private static void testCMoveILEforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
1466         for (int i = 0; i < a.length; i++) {
1467             float cc = c[i];
1468             float dd = d[i];
1469             r2[i] = cc + dd;
1470             r[i] = (a[i] <= b[i]) ? cc : dd;
1471         }
1472     }
1473 
1474     //     I fo D
1475     @Test
1476     @IR(failOn = {IRNode.STORE_VECTOR})
1477     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_I, ">0"},
1478         applyIf = {"UseVectorCmov", "false"},
1479         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1480     private static void testCMoveIEQforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
1481         for (int i = 0; i < a.length; i++) {
1482             double cc = c[i];
1483             double dd = d[i];
1484             r2[i] = cc + dd;
1485             r[i] = (a[i] == b[i]) ? cc : dd;
1486         }
1487     }
1488 
1489     @Test
1490     @IR(failOn = {IRNode.STORE_VECTOR})
1491     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_I, ">0"},
1492         applyIf = {"UseVectorCmov", "false"},
1493         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1494     private static void testCMoveINEforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
1495         for (int i = 0; i < a.length; i++) {
1496             double cc = c[i];
1497             double dd = d[i];
1498             r2[i] = cc + dd;
1499             r[i] = (a[i] != b[i]) ? cc : dd;
1500         }
1501     }
1502 
1503     @Test
1504     @IR(failOn = {IRNode.STORE_VECTOR})
1505     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_I, ">0"},
1506         applyIf = {"UseVectorCmov", "false"},
1507         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1508     private static void testCMoveIGTforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
1509         for (int i = 0; i < a.length; i++) {
1510             double cc = c[i];
1511             double dd = d[i];
1512             r2[i] = cc + dd;
1513             r[i] = (a[i] > b[i]) ? cc : dd;
1514         }
1515     }
1516 
1517     @Test
1518     @IR(failOn = {IRNode.STORE_VECTOR})
1519     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_I, ">0"},
1520         applyIf = {"UseVectorCmov", "false"},
1521         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1522     private static void testCMoveIGEforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
1523         for (int i = 0; i < a.length; i++) {
1524             double cc = c[i];
1525             double dd = d[i];
1526             r2[i] = cc + dd;
1527             r[i] = (a[i] >= b[i]) ? cc : dd;
1528         }
1529     }
1530 
1531     @Test
1532     @IR(failOn = {IRNode.STORE_VECTOR})
1533     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_I, ">0"},
1534         applyIf = {"UseVectorCmov", "false"},
1535         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1536     private static void testCMoveILTforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
1537         for (int i = 0; i < a.length; i++) {
1538             double cc = c[i];
1539             double dd = d[i];
1540             r2[i] = cc + dd;
1541             r[i] = (a[i] < b[i]) ? cc : dd;
1542         }
1543     }
1544 
1545     @Test
1546     @IR(failOn = {IRNode.STORE_VECTOR})
1547     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_I, ">0"},
1548         applyIf = {"UseVectorCmov", "false"},
1549         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1550     private static void testCMoveILEforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
1551         for (int i = 0; i < a.length; i++) {
1552             double cc = c[i];
1553             double dd = d[i];
1554             r2[i] = cc + dd;
1555             r[i] = (a[i] <= b[i]) ? cc : dd;
1556         }
1557     }
1558 
1559     //     L fo I
1560     @Test
1561     @IR(failOn = {IRNode.STORE_VECTOR})
1562     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_L, ">0"},
1563     //     applyIf = {"UseVectorCmov", "false"},
1564     //     applyIfPlatform = {"riscv64", "true"})
1565     private static void testCMoveLEQforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
1566         for (int i = 0; i < a.length; i++) {
1567             int cc = c[i];
1568             int dd = d[i];
1569             r2[i] = cc + dd;
1570             r[i] = (a[i] == b[i]) ? cc : dd;
1571         }
1572     }
1573 
1574     @Test
1575     @IR(failOn = {IRNode.STORE_VECTOR})
1576     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_L, ">0"},
1577     //     applyIf = {"UseVectorCmov", "false"},
1578     //     applyIfPlatform = {"riscv64", "true"})
1579     private static void testCMoveLNEforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
1580         for (int i = 0; i < a.length; i++) {
1581             int cc = c[i];
1582             int dd = d[i];
1583             r2[i] = cc + dd;
1584             r[i] = (a[i] != b[i]) ? cc : dd;
1585         }
1586     }
1587 
1588     @Test
1589     @IR(failOn = {IRNode.STORE_VECTOR})
1590     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_L, ">0"},
1591     //     applyIf = {"UseVectorCmov", "false"},
1592     //     applyIfPlatform = {"riscv64", "true"})
1593     private static void testCMoveLGTforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
1594         for (int i = 0; i < a.length; i++) {
1595             int cc = c[i];
1596             int dd = d[i];
1597             r2[i] = cc + dd;
1598             r[i] = (a[i] > b[i]) ? cc : dd;
1599         }
1600     }
1601 
1602     @Test
1603     @IR(failOn = {IRNode.STORE_VECTOR})
1604     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_L, ">0"},
1605     //     applyIf = {"UseVectorCmov", "false"},
1606     //     applyIfPlatform = {"riscv64", "true"})
1607     private static void testCMoveLGEforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
1608         for (int i = 0; i < a.length; i++) {
1609             int cc = c[i];
1610             int dd = d[i];
1611             r2[i] = cc + dd;
1612             r[i] = (a[i] >= b[i]) ? cc : dd;
1613         }
1614     }
1615 
1616     @Test
1617     @IR(failOn = {IRNode.STORE_VECTOR})
1618     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_L, ">0"},
1619     //     applyIf = {"UseVectorCmov", "false"},
1620     //     applyIfPlatform = {"riscv64", "true"})
1621     private static void testCMoveLLTforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
1622         for (int i = 0; i < a.length; i++) {
1623             int cc = c[i];
1624             int dd = d[i];
1625             r2[i] = cc + dd;
1626             r[i] = (a[i] < b[i]) ? cc : dd;
1627         }
1628     }
1629 
1630     @Test
1631     @IR(failOn = {IRNode.STORE_VECTOR})
1632     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_L, ">0"},
1633     //     applyIf = {"UseVectorCmov", "false"},
1634     //     applyIfPlatform = {"riscv64", "true"})
1635     private static void testCMoveLLEforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
1636         for (int i = 0; i < a.length; i++) {
1637             int cc = c[i];
1638             int dd = d[i];
1639             r2[i] = cc + dd;
1640             r[i] = (a[i] <= b[i]) ? cc : dd;
1641         }
1642     }
1643 
1644     //     L fo L
1645     @Test
1646     @IR(failOn = {IRNode.STORE_VECTOR})
1647     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_L, ">0"},
1648     //     applyIf = {"UseVectorCmov", "false"},
1649     //     applyIfPlatform = {"riscv64", "true"})
1650     private static void testCMoveLEQforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
1651         for (int i = 0; i < a.length; i++) {
1652             long cc = c[i];
1653             long dd = d[i];
1654             r2[i] = cc + dd;
1655             r[i] = (a[i] == b[i]) ? cc : dd;
1656         }
1657     }
1658 
1659     @Test
1660     @IR(failOn = {IRNode.STORE_VECTOR})
1661     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_L, ">0"},
1662     //     applyIf = {"UseVectorCmov", "false"},
1663     //     applyIfPlatform = {"riscv64", "true"})
1664     private static void testCMoveLNEforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
1665         for (int i = 0; i < a.length; i++) {
1666             long cc = c[i];
1667             long dd = d[i];
1668             r2[i] = cc + dd;
1669             r[i] = (a[i] != b[i]) ? cc : dd;
1670         }
1671     }
1672 
1673     @Test
1674     @IR(failOn = {IRNode.STORE_VECTOR})
1675     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_L, ">0"},
1676     //     applyIf = {"UseVectorCmov", "false"},
1677     //     applyIfPlatform = {"riscv64", "true"})
1678     private static void testCMoveLGTforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
1679         for (int i = 0; i < a.length; i++) {
1680             long cc = c[i];
1681             long dd = d[i];
1682             r2[i] = cc + dd;
1683             r[i] = (a[i] > b[i]) ? cc : dd;
1684         }
1685     }
1686 
1687     @Test
1688     @IR(failOn = {IRNode.STORE_VECTOR})
1689     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_L, ">0"},
1690     //     applyIf = {"UseVectorCmov", "false"},
1691     //     applyIfPlatform = {"riscv64", "true"})
1692     private static void testCMoveLGEforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
1693         for (int i = 0; i < a.length; i++) {
1694             long cc = c[i];
1695             long dd = d[i];
1696             r2[i] = cc + dd;
1697             r[i] = (a[i] >= b[i]) ? cc : dd;
1698         }
1699     }
1700 
1701     @Test
1702     @IR(failOn = {IRNode.STORE_VECTOR})
1703     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_L, ">0"},
1704     //     applyIf = {"UseVectorCmov", "false"},
1705     //     applyIfPlatform = {"riscv64", "true"})
1706     private static void testCMoveLLTforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
1707         for (int i = 0; i < a.length; i++) {
1708             long cc = c[i];
1709             long dd = d[i];
1710             r2[i] = cc + dd;
1711             r[i] = (a[i] < b[i]) ? cc : dd;
1712         }
1713     }
1714 
1715     @Test
1716     @IR(failOn = {IRNode.STORE_VECTOR})
1717     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_L, ">0"},
1718     //     applyIf = {"UseVectorCmov", "false"},
1719     //     applyIfPlatform = {"riscv64", "true"})
1720     private static void testCMoveLLEforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
1721         for (int i = 0; i < a.length; i++) {
1722             long cc = c[i];
1723             long dd = d[i];
1724             r2[i] = cc + dd;
1725             r[i] = (a[i] <= b[i]) ? cc : dd;
1726         }
1727     }
1728 
1729     //     L fo F
1730     @Test
1731     @IR(failOn = {IRNode.STORE_VECTOR})
1732     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_L, ">0"},
1733         applyIf = {"UseVectorCmov", "false"},
1734         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1735     private static void testCMoveLEQforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
1736         for (int i = 0; i < a.length; i++) {
1737             float cc = c[i];
1738             float dd = d[i];
1739             r2[i] = cc + dd;
1740             r[i] = (a[i] == b[i]) ? cc : dd;
1741         }
1742     }
1743 
1744     @Test
1745     @IR(failOn = {IRNode.STORE_VECTOR})
1746     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_L, ">0"},
1747         applyIf = {"UseVectorCmov", "false"},
1748         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1749     private static void testCMoveLNEforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
1750         for (int i = 0; i < a.length; i++) {
1751             float cc = c[i];
1752             float dd = d[i];
1753             r2[i] = cc + dd;
1754             r[i] = (a[i] != b[i]) ? cc : dd;
1755         }
1756     }
1757 
1758     @Test
1759     @IR(failOn = {IRNode.STORE_VECTOR})
1760     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_L, ">0"},
1761         applyIf = {"UseVectorCmov", "false"},
1762         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1763     private static void testCMoveLGTforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
1764         for (int i = 0; i < a.length; i++) {
1765             float cc = c[i];
1766             float dd = d[i];
1767             r2[i] = cc + dd;
1768             r[i] = (a[i] > b[i]) ? cc : dd;
1769         }
1770     }
1771 
1772     @Test
1773     @IR(failOn = {IRNode.STORE_VECTOR})
1774     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_L, ">0"},
1775         applyIf = {"UseVectorCmov", "false"},
1776         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1777     private static void testCMoveLGEforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
1778         for (int i = 0; i < a.length; i++) {
1779             float cc = c[i];
1780             float dd = d[i];
1781             r2[i] = cc + dd;
1782             r[i] = (a[i] >= b[i]) ? cc : dd;
1783         }
1784     }
1785 
1786     @Test
1787     @IR(failOn = {IRNode.STORE_VECTOR})
1788     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_L, ">0"},
1789         applyIf = {"UseVectorCmov", "false"},
1790         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1791     private static void testCMoveLLTforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
1792         for (int i = 0; i < a.length; i++) {
1793             float cc = c[i];
1794             float dd = d[i];
1795             r2[i] = cc + dd;
1796             r[i] = (a[i] < b[i]) ? cc : dd;
1797         }
1798     }
1799 
1800     @Test
1801     @IR(failOn = {IRNode.STORE_VECTOR})
1802     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_L, ">0"},
1803         applyIf = {"UseVectorCmov", "false"},
1804         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1805     private static void testCMoveLLEforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
1806         for (int i = 0; i < a.length; i++) {
1807             float cc = c[i];
1808             float dd = d[i];
1809             r2[i] = cc + dd;
1810             r[i] = (a[i] <= b[i]) ? cc : dd;
1811         }
1812     }
1813 
1814     //     L fo D
1815     @Test
1816     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1817                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1818                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1819                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1820                   IRNode.STORE_VECTOR, ">0"},
1821         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
1822         applyIf = {"UseVectorCmov", "true"})
1823     @IR(failOn = {IRNode.STORE_VECTOR},
1824         applyIf = {"UseVectorCmov", "false"})
1825     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_L, ">0"},
1826         applyIf = {"UseVectorCmov", "false"},
1827         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1828     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
1829     private static void testCMoveLEQforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
1830         for (int i = 0; i < a.length; i++) {
1831             double cc = c[i];
1832             double dd = d[i];
1833             r2[i] = cc + dd;
1834             r[i] = (a[i] == b[i]) ? cc : dd;
1835         }
1836     }
1837 
1838     @Test
1839     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1840                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1841                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1842                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1843                   IRNode.STORE_VECTOR, ">0"},
1844         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
1845         applyIf = {"UseVectorCmov", "true"})
1846     @IR(failOn = {IRNode.STORE_VECTOR},
1847         applyIf = {"UseVectorCmov", "false"})
1848     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_L, ">0"},
1849         applyIf = {"UseVectorCmov", "false"},
1850         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1851     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
1852     private static void testCMoveLNEforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
1853         for (int i = 0; i < a.length; i++) {
1854             double cc = c[i];
1855             double dd = d[i];
1856             r2[i] = cc + dd;
1857             r[i] = (a[i] != b[i]) ? cc : dd;
1858         }
1859     }
1860 
1861     @Test
1862     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1863                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1864                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1865                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1866                   IRNode.STORE_VECTOR, ">0"},
1867         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
1868         applyIf = {"UseVectorCmov", "true"})
1869     @IR(failOn = {IRNode.STORE_VECTOR},
1870         applyIf = {"UseVectorCmov", "false"})
1871     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_L, ">0"},
1872         applyIf = {"UseVectorCmov", "false"},
1873         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1874     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
1875     private static void testCMoveLGTforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
1876         for (int i = 0; i < a.length; i++) {
1877             double cc = c[i];
1878             double dd = d[i];
1879             r2[i] = cc + dd;
1880             r[i] = (a[i] > b[i]) ? cc : dd;
1881         }
1882     }
1883 
1884     @Test
1885     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1886                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1887                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1888                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1889                   IRNode.STORE_VECTOR, ">0"},
1890         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
1891         applyIf = {"UseVectorCmov", "true"})
1892     @IR(failOn = {IRNode.STORE_VECTOR},
1893         applyIf = {"UseVectorCmov", "false"})
1894     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_L, ">0"},
1895         applyIf = {"UseVectorCmov", "false"},
1896         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1897     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
1898     private static void testCMoveLGEforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
1899         for (int i = 0; i < a.length; i++) {
1900             double cc = c[i];
1901             double dd = d[i];
1902             r2[i] = cc + dd;
1903             r[i] = (a[i] >= b[i]) ? cc : dd;
1904         }
1905     }
1906 
1907     @Test
1908     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1909                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1910                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1911                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1912                   IRNode.STORE_VECTOR, ">0"},
1913         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
1914         applyIf = {"UseVectorCmov", "true"})
1915     @IR(failOn = {IRNode.STORE_VECTOR},
1916         applyIf = {"UseVectorCmov", "false"})
1917     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_L, ">0"},
1918         applyIf = {"UseVectorCmov", "false"},
1919         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1920     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
1921     private static void testCMoveLLTforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
1922         for (int i = 0; i < a.length; i++) {
1923             double cc = c[i];
1924             double dd = d[i];
1925             r2[i] = cc + dd;
1926             r[i] = (a[i] < b[i]) ? cc : dd;
1927         }
1928     }
1929 
1930     @Test
1931     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1932                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1933                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1934                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
1935                   IRNode.STORE_VECTOR, ">0"},
1936         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
1937         applyIf = {"UseVectorCmov", "true"})
1938     @IR(failOn = {IRNode.STORE_VECTOR},
1939         applyIf = {"UseVectorCmov", "false"})
1940     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_L, ">0"},
1941         applyIf = {"UseVectorCmov", "false"},
1942         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
1943     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
1944     private static void testCMoveLLEforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
1945         for (int i = 0; i < a.length; i++) {
1946             double cc = c[i];
1947             double dd = d[i];
1948             r2[i] = cc + dd;
1949             r[i] = (a[i] <= b[i]) ? cc : dd;
1950         }
1951     }
1952 
1953     // Unsigned comparison: I/L
1954     //     I fo I
1955     @Test
1956     @IR(failOn = {IRNode.STORE_VECTOR})
1957     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_U, ">0"},
1958     //     applyIf = {"UseVectorCmov", "false"},
1959     //     applyIfPlatform = {"riscv64", "true"})
1960     private static void testCMoveUIEQforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
1961         for (int i = 0; i < a.length; i++) {
1962             int cc = c[i];
1963             int dd = d[i];
1964             r2[i] = cc + dd;
1965             r[i] = Integer.compareUnsigned(a[i], b[i]) == 0 ? cc : dd;
1966         }
1967     }
1968 
1969     @Test
1970     @IR(failOn = {IRNode.STORE_VECTOR})
1971     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_U, ">0"},
1972     //     applyIf = {"UseVectorCmov", "false"},
1973     //     applyIfPlatform = {"riscv64", "true"})
1974     private static void testCMoveUINEforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
1975         for (int i = 0; i < a.length; i++) {
1976             int cc = c[i];
1977             int dd = d[i];
1978             r2[i] = cc + dd;
1979             r[i] = Integer.compareUnsigned(a[i], b[i]) != 0 ? cc : dd;
1980         }
1981     }
1982 
1983     @Test
1984     @IR(failOn = {IRNode.STORE_VECTOR})
1985     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_U, ">0"},
1986     //     applyIf = {"UseVectorCmov", "false"},
1987     //     applyIfPlatform = {"riscv64", "true"})
1988     private static void testCMoveUIGTforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
1989         for (int i = 0; i < a.length; i++) {
1990             int cc = c[i];
1991             int dd = d[i];
1992             r2[i] = cc + dd;
1993             r[i] = Integer.compareUnsigned(a[i], b[i]) > 0 ? cc : dd;
1994         }
1995     }
1996 
1997     @Test
1998     @IR(failOn = {IRNode.STORE_VECTOR})
1999     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_U, ">0"},
2000     //     applyIf = {"UseVectorCmov", "false"},
2001     //     applyIfPlatform = {"riscv64", "true"})
2002     private static void testCMoveUIGEforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
2003         for (int i = 0; i < a.length; i++) {
2004             int cc = c[i];
2005             int dd = d[i];
2006             r2[i] = cc + dd;
2007             r[i] = Integer.compareUnsigned(a[i], b[i]) >= 0 ? cc : dd;
2008         }
2009     }
2010 
2011     @Test
2012     @IR(failOn = {IRNode.STORE_VECTOR})
2013     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_U, ">0"},
2014     //     applyIf = {"UseVectorCmov", "false"},
2015     //     applyIfPlatform = {"riscv64", "true"})
2016     private static void testCMoveUILTforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
2017         for (int i = 0; i < a.length; i++) {
2018             int cc = c[i];
2019             int dd = d[i];
2020             r2[i] = cc + dd;
2021             r[i] = Integer.compareUnsigned(a[i], b[i]) < 0 ? cc : dd;
2022         }
2023     }
2024 
2025     @Test
2026     @IR(failOn = {IRNode.STORE_VECTOR})
2027     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_U, ">0"},
2028     //     applyIf = {"UseVectorCmov", "false"},
2029     //     applyIfPlatform = {"riscv64", "true"})
2030     private static void testCMoveUILEforI(int[] a, int[] b, int[] c, int[] d, int[] r, int[] r2) {
2031         for (int i = 0; i < a.length; i++) {
2032             int cc = c[i];
2033             int dd = d[i];
2034             r2[i] = cc + dd;
2035             r[i] = Integer.compareUnsigned(a[i], b[i]) <= 0 ? cc : dd;
2036         }
2037     }
2038 
2039     //     I fo L
2040     @Test
2041     @IR(failOn = {IRNode.STORE_VECTOR})
2042     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_U, ">0"},
2043     //     applyIf = {"UseVectorCmov", "false"},
2044     //     applyIfPlatform = {"riscv64", "true"})
2045     private static void testCMoveUIEQforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
2046         for (int i = 0; i < a.length; i++) {
2047             long cc = c[i];
2048             long dd = d[i];
2049             r2[i] = cc + dd;
2050             r[i] = Integer.compareUnsigned(a[i], b[i]) == 0 ? cc : dd;
2051         }
2052     }
2053 
2054     @Test
2055     @IR(failOn = {IRNode.STORE_VECTOR})
2056     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_U, ">0"},
2057     //     applyIf = {"UseVectorCmov", "false"},
2058     //     applyIfPlatform = {"riscv64", "true"})
2059     private static void testCMoveUINEforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
2060         for (int i = 0; i < a.length; i++) {
2061             long cc = c[i];
2062             long dd = d[i];
2063             r2[i] = cc + dd;
2064             r[i] = Integer.compareUnsigned(a[i], b[i]) != 0 ? cc : dd;
2065         }
2066     }
2067 
2068     @Test
2069     @IR(failOn = {IRNode.STORE_VECTOR})
2070     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_U, ">0"},
2071     //     applyIf = {"UseVectorCmov", "false"},
2072     //     applyIfPlatform = {"riscv64", "true"})
2073     private static void testCMoveUIGTforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
2074         for (int i = 0; i < a.length; i++) {
2075             long cc = c[i];
2076             long dd = d[i];
2077             r2[i] = cc + dd;
2078             r[i] = Integer.compareUnsigned(a[i], b[i]) > 0 ? cc : dd;
2079         }
2080     }
2081 
2082     @Test
2083     @IR(failOn = {IRNode.STORE_VECTOR})
2084     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_U, ">0"},
2085     //     applyIf = {"UseVectorCmov", "false"},
2086     //     applyIfPlatform = {"riscv64", "true"})
2087     private static void testCMoveUIGEforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
2088         for (int i = 0; i < a.length; i++) {
2089             long cc = c[i];
2090             long dd = d[i];
2091             r2[i] = cc + dd;
2092             r[i] = Integer.compareUnsigned(a[i], b[i]) >= 0 ? cc : dd;
2093         }
2094     }
2095 
2096     @Test
2097     @IR(failOn = {IRNode.STORE_VECTOR})
2098     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_U, ">0"},
2099     //     applyIf = {"UseVectorCmov", "false"},
2100     //     applyIfPlatform = {"riscv64", "true"})
2101     private static void testCMoveUILTforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
2102         for (int i = 0; i < a.length; i++) {
2103             long cc = c[i];
2104             long dd = d[i];
2105             r2[i] = cc + dd;
2106             r[i] = Integer.compareUnsigned(a[i], b[i]) < 0 ? cc : dd;
2107         }
2108     }
2109 
2110     @Test
2111     @IR(failOn = {IRNode.STORE_VECTOR})
2112     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_U, ">0"},
2113     //     applyIf = {"UseVectorCmov", "false"},
2114     //     applyIfPlatform = {"riscv64", "true"})
2115     private static void testCMoveUILEforL(int[] a, int[] b, long[] c, long[] d, long[] r, long[] r2) {
2116         for (int i = 0; i < a.length; i++) {
2117             long cc = c[i];
2118             long dd = d[i];
2119             r2[i] = cc + dd;
2120             r[i] = Integer.compareUnsigned(a[i], b[i]) <= 0 ? cc : dd;
2121         }
2122     }
2123 
2124     //     I fo F
2125     @Test
2126     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2127                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2128                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2129                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2130                   IRNode.STORE_VECTOR, ">0"},
2131         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
2132         applyIf = {"UseVectorCmov", "true"})
2133     @IR(failOn = {IRNode.STORE_VECTOR},
2134         applyIf = {"UseVectorCmov", "false"})
2135     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_U, ">0"},
2136         applyIf = {"UseVectorCmov", "false"},
2137             applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2138     private static void testCMoveUIEQforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
2139         for (int i = 0; i < a.length; i++) {
2140             float cc = c[i];
2141             float dd = d[i];
2142             r2[i] = cc + dd;
2143             r[i] = Integer.compareUnsigned(a[i], b[i]) == 0 ? cc : dd;
2144         }
2145     }
2146 
2147     @Test
2148     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2149                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2150                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2151                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2152                   IRNode.STORE_VECTOR, ">0"},
2153         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
2154         applyIf = {"UseVectorCmov", "true"})
2155     @IR(failOn = {IRNode.STORE_VECTOR},
2156         applyIf = {"UseVectorCmov", "false"})
2157     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_U, ">0"},
2158         applyIf = {"UseVectorCmov", "false"},
2159             applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2160     private static void testCMoveUINEforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
2161         for (int i = 0; i < a.length; i++) {
2162             float cc = c[i];
2163             float dd = d[i];
2164             r2[i] = cc + dd;
2165             r[i] = Integer.compareUnsigned(a[i], b[i]) != 0 ? cc : dd;
2166         }
2167     }
2168 
2169     @Test
2170     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2171                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2172                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2173                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2174                   IRNode.STORE_VECTOR, ">0"},
2175         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
2176         applyIf = {"UseVectorCmov", "true"})
2177     @IR(failOn = {IRNode.STORE_VECTOR},
2178         applyIf = {"UseVectorCmov", "false"})
2179     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_U, ">0"},
2180         applyIf = {"UseVectorCmov", "false"},
2181             applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2182     private static void testCMoveUIGTforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
2183         for (int i = 0; i < a.length; i++) {
2184             float cc = c[i];
2185             float dd = d[i];
2186             r2[i] = cc + dd;
2187             r[i] = Integer.compareUnsigned(a[i], b[i]) > 0 ? cc : dd;
2188         }
2189     }
2190 
2191     @Test
2192     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2193                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2194                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2195                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2196                   IRNode.STORE_VECTOR, ">0"},
2197         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
2198         applyIf = {"UseVectorCmov", "true"})
2199     @IR(failOn = {IRNode.STORE_VECTOR},
2200         applyIf = {"UseVectorCmov", "false"})
2201     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_U, ">0"},
2202         applyIf = {"UseVectorCmov", "false"},
2203             applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2204     private static void testCMoveUIGEforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
2205         for (int i = 0; i < a.length; i++) {
2206             float cc = c[i];
2207             float dd = d[i];
2208             r2[i] = cc + dd;
2209             r[i] = Integer.compareUnsigned(a[i], b[i]) >= 0 ? cc : dd;
2210         }
2211     }
2212 
2213     @Test
2214     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2215                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2216                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2217                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2218                   IRNode.STORE_VECTOR, ">0"},
2219         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
2220         applyIf = {"UseVectorCmov", "true"})
2221     @IR(failOn = {IRNode.STORE_VECTOR},
2222         applyIf = {"UseVectorCmov", "false"})
2223     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_U, ">0"},
2224         applyIf = {"UseVectorCmov", "false"},
2225             applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2226     private static void testCMoveUILTforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
2227         for (int i = 0; i < a.length; i++) {
2228             float cc = c[i];
2229             float dd = d[i];
2230             r2[i] = cc + dd;
2231             r[i] = Integer.compareUnsigned(a[i], b[i]) < 0 ? cc : dd;
2232         }
2233     }
2234 
2235     @Test
2236     @IR(counts = {IRNode.LOAD_VECTOR_I,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2237                   IRNode.LOAD_VECTOR_F,     IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2238                   IRNode.VECTOR_MASK_CMP_I, IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2239                   IRNode.VECTOR_BLEND_F,    IRNode.VECTOR_SIZE + "min(max_int, max_float)", ">0",
2240                   IRNode.STORE_VECTOR, ">0"},
2241         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
2242         applyIf = {"UseVectorCmov", "true"})
2243     @IR(failOn = {IRNode.STORE_VECTOR},
2244         applyIf = {"UseVectorCmov", "false"})
2245     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_U, ">0"},
2246         applyIf = {"UseVectorCmov", "false"},
2247             applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2248     private static void testCMoveUILEforF(int[] a, int[] b, float[] c, float[] d, float[] r, float[] r2) {
2249         for (int i = 0; i < a.length; i++) {
2250             float cc = c[i];
2251             float dd = d[i];
2252             r2[i] = cc + dd;
2253             r[i] = Integer.compareUnsigned(a[i], b[i]) <= 0 ? cc : dd;
2254         }
2255     }
2256 
2257     //     I fo D
2258     @Test
2259     @IR(failOn = {IRNode.STORE_VECTOR})
2260     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_U, ">0"},
2261         applyIf = {"UseVectorCmov", "false"},
2262         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2263     private static void testCMoveUIEQforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
2264         for (int i = 0; i < a.length; i++) {
2265             double cc = c[i];
2266             double dd = d[i];
2267             r2[i] = cc + dd;
2268             r[i] = Integer.compareUnsigned(a[i], b[i]) == 0 ? cc : dd;
2269         }
2270     }
2271 
2272     @Test
2273     @IR(failOn = {IRNode.STORE_VECTOR})
2274     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_U, ">0"},
2275         applyIf = {"UseVectorCmov", "false"},
2276         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2277     private static void testCMoveUINEforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
2278         for (int i = 0; i < a.length; i++) {
2279             double cc = c[i];
2280             double dd = d[i];
2281             r2[i] = cc + dd;
2282             r[i] = Integer.compareUnsigned(a[i], b[i]) != 0 ? cc : dd;
2283         }
2284     }
2285 
2286     @Test
2287     @IR(failOn = {IRNode.STORE_VECTOR})
2288     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_U, ">0"},
2289         applyIf = {"UseVectorCmov", "false"},
2290         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2291     private static void testCMoveUIGTforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
2292         for (int i = 0; i < a.length; i++) {
2293             double cc = c[i];
2294             double dd = d[i];
2295             r2[i] = cc + dd;
2296             r[i] = Integer.compareUnsigned(a[i], b[i]) > 0 ? cc : dd;
2297         }
2298     }
2299 
2300     @Test
2301     @IR(failOn = {IRNode.STORE_VECTOR})
2302     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_U, ">0"},
2303         applyIf = {"UseVectorCmov", "false"},
2304         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2305     private static void testCMoveUIGEforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
2306         for (int i = 0; i < a.length; i++) {
2307             double cc = c[i];
2308             double dd = d[i];
2309             r2[i] = cc + dd;
2310             r[i] = Integer.compareUnsigned(a[i], b[i]) >= 0 ? cc : dd;
2311         }
2312     }
2313 
2314     @Test
2315     @IR(failOn = {IRNode.STORE_VECTOR})
2316     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_U, ">0"},
2317         applyIf = {"UseVectorCmov", "false"},
2318         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2319     private static void testCMoveUILTforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
2320         for (int i = 0; i < a.length; i++) {
2321             double cc = c[i];
2322             double dd = d[i];
2323             r2[i] = cc + dd;
2324             r[i] = Integer.compareUnsigned(a[i], b[i]) < 0 ? cc : dd;
2325         }
2326     }
2327 
2328     @Test
2329     @IR(failOn = {IRNode.STORE_VECTOR})
2330     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_U, ">0"},
2331         applyIf = {"UseVectorCmov", "false"},
2332         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2333     private static void testCMoveUILEforD(int[] a, int[] b, double[] c, double[] d, double[] r, double[] r2) {
2334         for (int i = 0; i < a.length; i++) {
2335             double cc = c[i];
2336             double dd = d[i];
2337             r2[i] = cc + dd;
2338             r[i] = Integer.compareUnsigned(a[i], b[i]) <= 0 ? cc : dd;
2339         }
2340     }
2341 
2342     //     L fo I
2343     @Test
2344     @IR(failOn = {IRNode.STORE_VECTOR})
2345     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_UL, ">0"},
2346     //     applyIf = {"UseVectorCmov", "false"},
2347     //     applyIfPlatform = {"riscv64", "true"})
2348     private static void testCMoveULEQforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
2349         for (int i = 0; i < a.length; i++) {
2350             int cc = c[i];
2351             int dd = d[i];
2352             r2[i] = cc + dd;
2353             r[i] = Long.compareUnsigned(a[i], b[i]) == 0 ? cc : dd;
2354         }
2355     }
2356 
2357     @Test
2358     @IR(failOn = {IRNode.STORE_VECTOR})
2359     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_UL, ">0"},
2360     //     applyIf = {"UseVectorCmov", "false"},
2361     //     applyIfPlatform = {"riscv64", "true"})
2362     private static void testCMoveULNEforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
2363         for (int i = 0; i < a.length; i++) {
2364             int cc = c[i];
2365             int dd = d[i];
2366             r2[i] = cc + dd;
2367             r[i] = Long.compareUnsigned(a[i], b[i]) != 0 ? cc : dd;
2368         }
2369     }
2370 
2371     @Test
2372     @IR(failOn = {IRNode.STORE_VECTOR})
2373     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_UL, ">0"},
2374     //     applyIf = {"UseVectorCmov", "false"},
2375     //     applyIfPlatform = {"riscv64", "true"})
2376     private static void testCMoveULGTforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
2377         for (int i = 0; i < a.length; i++) {
2378             int cc = c[i];
2379             int dd = d[i];
2380             r2[i] = cc + dd;
2381             r[i] = Long.compareUnsigned(a[i], b[i]) > 0 ? cc : dd;
2382         }
2383     }
2384 
2385     @Test
2386     @IR(failOn = {IRNode.STORE_VECTOR})
2387     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_UL, ">0"},
2388     //     applyIf = {"UseVectorCmov", "false"},
2389     //     applyIfPlatform = {"riscv64", "true"})
2390     private static void testCMoveULGEforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
2391         for (int i = 0; i < a.length; i++) {
2392             int cc = c[i];
2393             int dd = d[i];
2394             r2[i] = cc + dd;
2395             r[i] = Long.compareUnsigned(a[i], b[i]) >= 0 ? cc : dd;
2396         }
2397     }
2398 
2399     @Test
2400     @IR(failOn = {IRNode.STORE_VECTOR})
2401     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_UL, ">0"},
2402     //     applyIf = {"UseVectorCmov", "false"},
2403     //     applyIfPlatform = {"riscv64", "true"})
2404     private static void testCMoveULLTforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
2405         for (int i = 0; i < a.length; i++) {
2406             int cc = c[i];
2407             int dd = d[i];
2408             r2[i] = cc + dd;
2409             r[i] = Long.compareUnsigned(a[i], b[i]) < 0 ? cc : dd;
2410         }
2411     }
2412 
2413     @Test
2414     @IR(failOn = {IRNode.STORE_VECTOR})
2415     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_UL, ">0"},
2416     //     applyIf = {"UseVectorCmov", "false"},
2417     //     applyIfPlatform = {"riscv64", "true"})
2418     private static void testCMoveULLEforI(long[] a, long[] b, int[] c, int[] d, int[] r, int[] r2) {
2419         for (int i = 0; i < a.length; i++) {
2420             int cc = c[i];
2421             int dd = d[i];
2422             r2[i] = cc + dd;
2423             r[i] = Long.compareUnsigned(a[i], b[i]) <= 0 ? cc : dd;
2424         }
2425     }
2426 
2427     //     L fo L
2428     @Test
2429     @IR(failOn = {IRNode.STORE_VECTOR})
2430     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_UL, ">0"},
2431     //     applyIf = {"UseVectorCmov", "false"},
2432     //     applyIfPlatform = {"riscv64", "true"})
2433     private static void testCMoveULEQforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
2434         for (int i = 0; i < a.length; i++) {
2435             long cc = c[i];
2436             long dd = d[i];
2437             r2[i] = cc + dd;
2438             r[i] = Long.compareUnsigned(a[i], b[i]) == 0 ? cc : dd;
2439         }
2440     }
2441 
2442     @Test
2443     @IR(failOn = {IRNode.STORE_VECTOR})
2444     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_UL, ">0"},
2445     //     applyIf = {"UseVectorCmov", "false"},
2446     //     applyIfPlatform = {"riscv64", "true"})
2447     private static void testCMoveULNEforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
2448         for (int i = 0; i < a.length; i++) {
2449             long cc = c[i];
2450             long dd = d[i];
2451             r2[i] = cc + dd;
2452             r[i] = Long.compareUnsigned(a[i], b[i]) != 0 ? cc : dd;
2453         }
2454     }
2455 
2456     @Test
2457     @IR(failOn = {IRNode.STORE_VECTOR})
2458     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_UL, ">0"},
2459     //     applyIf = {"UseVectorCmov", "false"},
2460     //     applyIfPlatform = {"riscv64", "true"})
2461     private static void testCMoveULGTforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
2462         for (int i = 0; i < a.length; i++) {
2463             long cc = c[i];
2464             long dd = d[i];
2465             r2[i] = cc + dd;
2466             r[i] = Long.compareUnsigned(a[i], b[i]) > 0 ? cc : dd;
2467         }
2468     }
2469 
2470     @Test
2471     @IR(failOn = {IRNode.STORE_VECTOR})
2472     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_UL, ">0"},
2473     //     applyIf = {"UseVectorCmov", "false"},
2474     //     applyIfPlatform = {"riscv64", "true"})
2475     private static void testCMoveULGEforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
2476         for (int i = 0; i < a.length; i++) {
2477             long cc = c[i];
2478             long dd = d[i];
2479             r2[i] = cc + dd;
2480             r[i] = Long.compareUnsigned(a[i], b[i]) >= 0 ? cc : dd;
2481         }
2482     }
2483 
2484     @Test
2485     @IR(failOn = {IRNode.STORE_VECTOR})
2486     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_UL, ">0"},
2487     //     applyIf = {"UseVectorCmov", "false"},
2488     //     applyIfPlatform = {"riscv64", "true"})
2489     private static void testCMoveULLTforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
2490         for (int i = 0; i < a.length; i++) {
2491             long cc = c[i];
2492             long dd = d[i];
2493             r2[i] = cc + dd;
2494             r[i] = Long.compareUnsigned(a[i], b[i]) < 0 ? cc : dd;
2495         }
2496     }
2497 
2498     @Test
2499     @IR(failOn = {IRNode.STORE_VECTOR})
2500     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_UL, ">0"},
2501     //     applyIf = {"UseVectorCmov", "false"},
2502     //     applyIfPlatform = {"riscv64", "true"})
2503     private static void testCMoveULLEforL(long[] a, long[] b, long[] c, long[] d, long[] r, long[] r2) {
2504         for (int i = 0; i < a.length; i++) {
2505             long cc = c[i];
2506             long dd = d[i];
2507             r2[i] = cc + dd;
2508             r[i] = Long.compareUnsigned(a[i], b[i]) <= 0 ? cc : dd;
2509         }
2510     }
2511 
2512     //     L fo F
2513     @Test
2514     @IR(failOn = {IRNode.STORE_VECTOR})
2515     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_UL, ">0"},
2516         applyIf = {"UseVectorCmov", "false"},
2517         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2518     private static void testCMoveULEQforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
2519         for (int i = 0; i < a.length; i++) {
2520             float cc = c[i];
2521             float dd = d[i];
2522             r2[i] = cc + dd;
2523             r[i] = Long.compareUnsigned(a[i], b[i]) == 0 ? cc : dd;
2524         }
2525     }
2526 
2527     @Test
2528     @IR(failOn = {IRNode.STORE_VECTOR})
2529     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_UL, ">0"},
2530         applyIf = {"UseVectorCmov", "false"},
2531         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2532     private static void testCMoveULNEforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
2533         for (int i = 0; i < a.length; i++) {
2534             float cc = c[i];
2535             float dd = d[i];
2536             r2[i] = cc + dd;
2537             r[i] = Long.compareUnsigned(a[i], b[i]) != 0 ? cc : dd;
2538         }
2539     }
2540 
2541     @Test
2542     @IR(failOn = {IRNode.STORE_VECTOR})
2543     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_UL, ">0"},
2544         applyIf = {"UseVectorCmov", "false"},
2545         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2546     private static void testCMoveULGTforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
2547         for (int i = 0; i < a.length; i++) {
2548             float cc = c[i];
2549             float dd = d[i];
2550             r2[i] = cc + dd;
2551             r[i] = Long.compareUnsigned(a[i], b[i]) > 0 ? cc : dd;
2552         }
2553     }
2554 
2555     @Test
2556     @IR(failOn = {IRNode.STORE_VECTOR})
2557     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_UL, ">0"},
2558         applyIf = {"UseVectorCmov", "false"},
2559         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2560     private static void testCMoveULGEforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
2561         for (int i = 0; i < a.length; i++) {
2562             float cc = c[i];
2563             float dd = d[i];
2564             r2[i] = cc + dd;
2565             r[i] = Long.compareUnsigned(a[i], b[i]) >= 0 ? cc : dd;
2566         }
2567     }
2568 
2569     @Test
2570     @IR(failOn = {IRNode.STORE_VECTOR})
2571     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_UL, ">0"},
2572         applyIf = {"UseVectorCmov", "false"},
2573         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2574     private static void testCMoveULLTforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
2575         for (int i = 0; i < a.length; i++) {
2576             float cc = c[i];
2577             float dd = d[i];
2578             r2[i] = cc + dd;
2579             r[i] = Long.compareUnsigned(a[i], b[i]) < 0 ? cc : dd;
2580         }
2581     }
2582 
2583     @Test
2584     @IR(failOn = {IRNode.STORE_VECTOR})
2585     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_UL, ">0"},
2586         applyIf = {"UseVectorCmov", "false"},
2587         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2588     private static void testCMoveULLEforF(long[] a, long[] b, float[] c, float[] d, float[] r, float[] r2) {
2589         for (int i = 0; i < a.length; i++) {
2590             float cc = c[i];
2591             float dd = d[i];
2592             r2[i] = cc + dd;
2593             r[i] = Long.compareUnsigned(a[i], b[i]) <= 0 ? cc : dd;
2594         }
2595     }
2596 
2597     //     L fo D
2598     @Test
2599     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2600                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2601                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2602                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2603                   IRNode.STORE_VECTOR, ">0"},
2604         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
2605         applyIf = {"UseVectorCmov", "true"})
2606     @IR(failOn = {IRNode.STORE_VECTOR},
2607         applyIf = {"UseVectorCmov", "false"})
2608     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_UL, ">0"},
2609         applyIf = {"UseVectorCmov", "false"},
2610         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2611     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
2612     private static void testCMoveULEQforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
2613         for (int i = 0; i < a.length; i++) {
2614             double cc = c[i];
2615             double dd = d[i];
2616             r2[i] = cc + dd;
2617             r[i] = Long.compareUnsigned(a[i], b[i]) == 0 ? cc : dd;
2618         }
2619     }
2620 
2621     @Test
2622     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2623                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2624                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2625                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2626                   IRNode.STORE_VECTOR, ">0"},
2627         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
2628         applyIf = {"UseVectorCmov", "true"})
2629     @IR(failOn = {IRNode.STORE_VECTOR},
2630         applyIf = {"UseVectorCmov", "false"})
2631     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_UL, ">0"},
2632         applyIf = {"UseVectorCmov", "false"},
2633         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2634     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
2635     private static void testCMoveULNEforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
2636         for (int i = 0; i < a.length; i++) {
2637             double cc = c[i];
2638             double dd = d[i];
2639             r2[i] = cc + dd;
2640             r[i] = Long.compareUnsigned(a[i], b[i]) != 0 ? cc : dd;
2641         }
2642     }
2643 
2644     @Test
2645     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2646                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2647                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2648                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2649                   IRNode.STORE_VECTOR, ">0"},
2650         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
2651         applyIf = {"UseVectorCmov", "true"})
2652     @IR(failOn = {IRNode.STORE_VECTOR},
2653         applyIf = {"UseVectorCmov", "false"})
2654     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_UL, ">0"},
2655         applyIf = {"UseVectorCmov", "false"},
2656         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2657     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
2658     private static void testCMoveULGTforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
2659         for (int i = 0; i < a.length; i++) {
2660             double cc = c[i];
2661             double dd = d[i];
2662             r2[i] = cc + dd;
2663             r[i] = Long.compareUnsigned(a[i], b[i]) > 0 ? cc : dd;
2664         }
2665     }
2666 
2667     @Test
2668     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2669                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2670                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2671                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2672                   IRNode.STORE_VECTOR, ">0"},
2673         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
2674         applyIf = {"UseVectorCmov", "true"})
2675     @IR(failOn = {IRNode.STORE_VECTOR},
2676         applyIf = {"UseVectorCmov", "false"})
2677     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_UL, ">0"},
2678         applyIf = {"UseVectorCmov", "false"},
2679         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2680     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
2681     private static void testCMoveULGEforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
2682         for (int i = 0; i < a.length; i++) {
2683             double cc = c[i];
2684             double dd = d[i];
2685             r2[i] = cc + dd;
2686             r[i] = Long.compareUnsigned(a[i], b[i]) >= 0 ? cc : dd;
2687         }
2688     }
2689 
2690     @Test
2691     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2692                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2693                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2694                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2695                   IRNode.STORE_VECTOR, ">0"},
2696         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
2697         applyIf = {"UseVectorCmov", "true"})
2698     @IR(failOn = {IRNode.STORE_VECTOR},
2699         applyIf = {"UseVectorCmov", "false"})
2700     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_UL, ">0"},
2701         applyIf = {"UseVectorCmov", "false"},
2702         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2703     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
2704     private static void testCMoveULLTforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
2705         for (int i = 0; i < a.length; i++) {
2706             double cc = c[i];
2707             double dd = d[i];
2708             r2[i] = cc + dd;
2709             r[i] = Long.compareUnsigned(a[i], b[i]) < 0 ? cc : dd;
2710         }
2711     }
2712 
2713     @Test
2714     @IR(counts = {IRNode.LOAD_VECTOR_L,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2715                   IRNode.LOAD_VECTOR_D,     IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2716                   IRNode.VECTOR_MASK_CMP_L, IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2717                   IRNode.VECTOR_BLEND_D,    IRNode.VECTOR_SIZE + "min(max_long, max_double)", ">0",
2718                   IRNode.STORE_VECTOR, ">0"},
2719         applyIfCPUFeatureOr = {"avx2", "true", "asimd", "true", "rvv", "true"},
2720         applyIf = {"UseVectorCmov", "true"})
2721     @IR(failOn = {IRNode.STORE_VECTOR},
2722         applyIf = {"UseVectorCmov", "false"})
2723     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_UL, ">0"},
2724         applyIf = {"UseVectorCmov", "false"},
2725         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2726     // Requires avx2, else L is restricted to 16 byte, and D has 32. That leads to a vector elements mismatch of 2 to 4.
2727     private static void testCMoveULLEforD(long[] a, long[] b, double[] c, double[] d, double[] r, double[] r2) {
2728         for (int i = 0; i < a.length; i++) {
2729             double cc = c[i];
2730             double dd = d[i];
2731             r2[i] = cc + dd;
2732             r[i] = Long.compareUnsigned(a[i], b[i]) <= 0 ? cc : dd;
2733         }
2734     }
2735 
2736     @Test
2737     @IR(failOn = {IRNode.STORE_VECTOR})
2738     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_F, ">0"},
2739     //     applyIf = {"UseVectorCmov", "false"},
2740     //     applyIfPlatform = {"riscv64", "true"})
2741     private static void testCMoveFGTforI(float[] a, float[] b, int[] c, int[] d, int[] r, int[] r2) {
2742         for (int i = 0; i < a.length; i++) {
2743             int cc = c[i];
2744             int dd = d[i];
2745             r2[i] = cc + dd;
2746             r[i] = (a[i] > b[i]) ? cc : dd;
2747         }
2748     }
2749 
2750     @Test
2751     @IR(failOn = {IRNode.STORE_VECTOR})
2752     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_F, ">0"},
2753     //     applyIf = {"UseVectorCmov", "false"},
2754     //     applyIfPlatform = {"riscv64", "true"})
2755     private static void testCMoveFGTforL(float[] a, float[] b, long[] c, long[] d, long[] r, long[] r2) {
2756         for (int i = 0; i < a.length; i++) {
2757             long cc = c[i];
2758             long dd = d[i];
2759             r2[i] = cc + dd;
2760             r[i] = (a[i] > b[i]) ? cc : dd;
2761         }
2762     }
2763 
2764     @Test
2765     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
2766                   IRNode.VECTOR_MASK_CMP_F, ">0",
2767                   IRNode.VECTOR_BLEND_F, ">0",
2768                   IRNode.STORE_VECTOR, ">0"},
2769         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
2770         applyIf = {"UseVectorCmov", "true"})
2771     @IR(failOn = {IRNode.STORE_VECTOR},
2772         applyIf = {"UseVectorCmov", "false"})
2773     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
2774         applyIf = {"UseVectorCmov", "false"},
2775         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2776     private static void testCMoveFGTforF(float[] a, float[] b, float[] c, float[] d, float[] r, float[] r2) {
2777         for (int i = 0; i < a.length; i++) {
2778             float cc = c[i];
2779             float dd = d[i];
2780             r2[i] = cc + dd;
2781             r[i] = (a[i] > b[i]) ? cc : dd;
2782         }
2783     }
2784 
2785     @Test
2786     @IR(failOn = {IRNode.STORE_VECTOR})
2787     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_F, ">0"},
2788         applyIf = {"UseVectorCmov", "false"},
2789         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2790     private static void testCMoveFGTforD(float[] a, float[] b, double[] c, double[] d, double[] r, double[] r2) {
2791         for (int i = 0; i < a.length; i++) {
2792             double cc = c[i];
2793             double dd = d[i];
2794             r2[i] = cc + dd;
2795             r[i] = (a[i] > b[i]) ? cc : dd;
2796         }
2797     }
2798 
2799     @Test
2800     @IR(failOn = {IRNode.STORE_VECTOR})
2801     // @IR(counts = {IRNode.CMOVE_I, ">0", IRNode.CMP_D, ">0"},
2802     //     applyIf = {"UseVectorCmov", "false"},
2803     //     applyIfPlatform = {"riscv64", "true"})
2804     private static void testCMoveDGTforI(double[] a, double[] b, int[] c, int[] d, int[] r, int[] r2) {
2805         for (int i = 0; i < a.length; i++) {
2806             int cc = c[i];
2807             int dd = d[i];
2808             r2[i] = cc + dd;
2809             r[i] = (a[i] > b[i]) ? cc : dd;
2810         }
2811     }
2812 
2813     @Test
2814     @IR(failOn = {IRNode.STORE_VECTOR})
2815     // @IR(counts = {IRNode.CMOVE_L, ">0", IRNode.CMP_D, ">0"},
2816     //     applyIf = {"UseVectorCmov", "false"},
2817     //     applyIfPlatform = {"riscv64", "true"})
2818     private static void testCMoveDGTforL(double[] a, double[] b, long[] c, long[] d, long[] r, long[] r2) {
2819         for (int i = 0; i < a.length; i++) {
2820             long cc = c[i];
2821             long dd = d[i];
2822             r2[i] = cc + dd;
2823             r[i] = (a[i] > b[i]) ? cc : dd;
2824         }
2825     }
2826 
2827     @Test
2828     @IR(failOn = {IRNode.STORE_VECTOR})
2829     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_D, ">0"},
2830         applyIf = {"UseVectorCmov", "false"},
2831         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2832     private static void testCMoveDGTforF(double[] a, double[] b, float[] c, float[] d, float[] r, float[] r2) {
2833         for (int i = 0; i < a.length; i++) {
2834             float cc = c[i];
2835             float dd = d[i];
2836             r2[i] = cc + dd;
2837             r[i] = (a[i] > b[i]) ? cc : dd;
2838         }
2839     }
2840 
2841     @Test
2842     @IR(counts = {IRNode.LOAD_VECTOR_D, ">0",
2843                   IRNode.VECTOR_MASK_CMP_D, ">0",
2844                   IRNode.VECTOR_BLEND_D, ">0",
2845                   IRNode.STORE_VECTOR, ">0"},
2846         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
2847         applyIf = {"UseVectorCmov", "true"})
2848     @IR(failOn = {IRNode.STORE_VECTOR},
2849         applyIf = {"UseVectorCmov", "false"})
2850     @IR(counts = {IRNode.CMOVE_D, ">0", IRNode.CMP_D, ">0"},
2851         applyIf = {"UseVectorCmov", "false"},
2852         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2853     private static void testCMoveDGTforD(double[] a, double[] b, double[] c, double[] d, double[] r, double[] r2) {
2854         for (int i = 0; i < a.length; i++) {
2855             double cc = c[i];
2856             double dd = d[i];
2857             r2[i] = cc + dd;
2858             r[i] = (a[i] > b[i]) ? cc : dd;
2859         }
2860     }
2861 
2862     // Use some constants in the comparison
2863     @Test
2864     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
2865                   IRNode.VECTOR_MASK_CMP_F, ">0",
2866                   IRNode.VECTOR_BLEND_F, ">0",
2867                   IRNode.STORE_VECTOR, ">0"},
2868         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
2869         applyIf = {"UseVectorCmov", "true"})
2870     @IR(failOn = {IRNode.STORE_VECTOR},
2871         applyIf = {"UseVectorCmov", "false"})
2872     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
2873         applyIf = {"UseVectorCmov", "false"},
2874         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2875     private static void testCMoveFGTforFCmpCon1(float a, float[] b, float[] c, float[] d, float[] r, float[] r2) {
2876         for (int i = 0; i < b.length; i++) {
2877             float cc = c[i];
2878             float dd = d[i];
2879             r2[i] = cc + dd;
2880             r[i] = (a > b[i]) ? cc : dd;
2881         }
2882     }
2883 
2884     @Test
2885     @IR(counts = {IRNode.LOAD_VECTOR_F, ">0",
2886                   IRNode.VECTOR_MASK_CMP_F, ">0",
2887                   IRNode.VECTOR_BLEND_F, ">0",
2888                   IRNode.STORE_VECTOR, ">0"},
2889         applyIfCPUFeatureOr = {"avx", "true", "asimd", "true", "rvv", "true"},
2890         applyIf = {"UseVectorCmov", "true"})
2891     @IR(failOn = {IRNode.STORE_VECTOR},
2892         applyIf = {"UseVectorCmov", "false"})
2893     @IR(counts = {IRNode.CMOVE_F, ">0", IRNode.CMP_F, ">0"},
2894         applyIf = {"UseVectorCmov", "false"},
2895         applyIfPlatformOr = {"riscv64", "true", "x64", "true", "aarch64", "true"})
2896     private static void testCMoveFGTforFCmpCon2(float[] a, float b, float[] c, float[] d, float[] r, float[] r2) {
2897         for (int i = 0; i < a.length; i++) {
2898             float cc = c[i];
2899             float dd = d[i];
2900             r2[i] = cc + dd;
2901             r[i] = (a[i] > b) ? cc : dd;
2902         }
2903     }
2904 
2905     // A case that is currently not supported and is not expected to vectorize
2906     @Test
2907     @IR(failOn = {IRNode.STORE_VECTOR})
2908     private static void testCMoveVDUnsupported() {
2909         double[] doublec = new double[SIZE];
2910         int seed = 1001;
2911         for (int i = 0; i < doublec.length; i++) {
2912             doublec[i] = (i % 2 == 0) ? seed + i : seed - i;
2913         }
2914     }
2915 
2916     @Warmup(0)
2917     @Run(test = {"testCMoveVFGT", "testCMoveVFLT","testCMoveVDLE", "testCMoveVDGE", "testCMoveVFEQ", "testCMoveVDNE",
2918                  "testCMoveVFGTSwap", "testCMoveVFLTSwap","testCMoveVDLESwap", "testCMoveVDGESwap",
2919                  "testCMoveFGTforFConst", "testCMoveFGEforFConst", "testCMoveFLTforFConst",
2920                  "testCMoveFLEforFConst", "testCMoveFEQforFConst", "testCMoveFNEQforFConst",
2921                  "testCMoveDGTforDConst", "testCMoveDGEforDConst", "testCMoveDLTforDConst",
2922                  "testCMoveDLEforDConst", "testCMoveDEQforDConst", "testCMoveDNEQforDConst",
2923                  "testCMoveFLTforFConstH2", "testCMoveFLEforFConstH2",
2924                  "testCMoveFYYforFConstH2", "testCMoveFXXforFConstH2",
2925                  "testCMoveDLTforDConstH2", "testCMoveDLEforDConstH2",
2926                  "testCMoveDYYforDConstH2", "testCMoveDXXforDConstH2"})
2927     private void testCMove_runner() {
2928         float[] floata = new float[SIZE];
2929         float[] floatb = new float[SIZE];
2930         float[] floatc = new float[SIZE];
2931         double[] doublea = new double[SIZE];
2932         double[] doubleb = new double[SIZE];
2933         double[] doublec = new double[SIZE];
2934 
2935         init(floata);
2936         init(floatb);
2937         init(doublea);
2938         init(doubleb);
2939 
2940         testCMoveVFGT(floata, floatb, floatc);
2941         testCMoveVDLE(doublea, doubleb, doublec);
2942         for (int i = 0; i < SIZE; i++) {
2943             Asserts.assertEquals(floatc[i], cmoveFloatGT(floata[i], floatb[i]));
2944             Asserts.assertEquals(doublec[i], cmoveDoubleLE(doublea[i], doubleb[i]));
2945         }
2946 
2947         testCMoveVFLT(floata, floatb, floatc);
2948         testCMoveVDGE(doublea, doubleb, doublec);
2949         for (int i = 0; i < SIZE; i++) {
2950             Asserts.assertEquals(floatc[i], cmoveFloatLT(floata[i], floatb[i]));
2951             Asserts.assertEquals(doublec[i], cmoveDoubleGE(doublea[i], doubleb[i]));
2952         }
2953 
2954         // Ensure we frequently have equals
2955         for (int i = 0; i < SIZE; i++) {
2956             if (i % 3 == 0) {
2957                 floatb[i] = floata[i];
2958                 doubleb[i] = doublea[i];
2959             }
2960         }
2961 
2962         testCMoveVFEQ(floata, floatb, floatc);
2963         testCMoveVDNE(doublea, doubleb, doublec);
2964         for (int i = 0; i < SIZE; i++) {
2965             Asserts.assertEquals(floatc[i], cmoveFloatEQ(floata[i], floatb[i]));
2966             Asserts.assertEquals(doublec[i], cmoveDoubleNE(doublea[i], doubleb[i]));
2967         }
2968 
2969         testCMoveVFGTSwap(floata, floatb, floatc);
2970         testCMoveVDLESwap(doublea, doubleb, doublec);
2971         for (int i = 0; i < SIZE; i++) {
2972             Asserts.assertEquals(floatc[i], cmoveFloatGTSwap(floata[i], floatb[i]));
2973             Asserts.assertEquals(doublec[i], cmoveDoubleLESwap(doublea[i], doubleb[i]));
2974         }
2975 
2976         testCMoveVFLTSwap(floata, floatb, floatc);
2977         testCMoveVDGESwap(doublea, doubleb, doublec);
2978         for (int i = 0; i < SIZE; i++) {
2979             Asserts.assertEquals(floatc[i], cmoveFloatLTSwap(floata[i], floatb[i]));
2980             Asserts.assertEquals(doublec[i], cmoveDoubleGESwap(doublea[i], doubleb[i]));
2981         }
2982 
2983         // Extensions: compare 2 values, and pick from 2 consts
2984         testCMoveFGTforFConst(floata, floatb, floatc);
2985         testCMoveDGTforDConst(doublea, doubleb, doublec);
2986         for (int i = 0; i < SIZE; i++) {
2987             Asserts.assertEquals(floatc[i], cmoveFGTforFConst(floata[i], floatb[i]));
2988             Asserts.assertEquals(doublec[i], cmoveDGTforDConst(doublea[i], doubleb[i]));
2989         }
2990 
2991         testCMoveFGEforFConst(floata, floatb, floatc);
2992         testCMoveDGEforDConst(doublea, doubleb, doublec);
2993         for (int i = 0; i < SIZE; i++) {
2994             Asserts.assertEquals(floatc[i], cmoveFGEforFConst(floata[i], floatb[i]));
2995             Asserts.assertEquals(doublec[i], cmoveDGEforDConst(doublea[i], doubleb[i]));
2996         }
2997 
2998         testCMoveFLTforFConst(floata, floatb, floatc);
2999         testCMoveDLTforDConst(doublea, doubleb, doublec);
3000         for (int i = 0; i < SIZE; i++) {
3001             Asserts.assertEquals(floatc[i], cmoveFLTforFConst(floata[i], floatb[i]));
3002             Asserts.assertEquals(doublec[i], cmoveDLTforDConst(doublea[i], doubleb[i]));
3003         }
3004 
3005         testCMoveFLEforFConst(floata, floatb, floatc);
3006         testCMoveDLEforDConst(doublea, doubleb, doublec);
3007         for (int i = 0; i < SIZE; i++) {
3008             Asserts.assertEquals(floatc[i], cmoveFLEforFConst(floata[i], floatb[i]));
3009             Asserts.assertEquals(doublec[i], cmoveDLEforDConst(doublea[i], doubleb[i]));
3010         }
3011 
3012         testCMoveFEQforFConst(floata, floatb, floatc);
3013         testCMoveDEQforDConst(doublea, doubleb, doublec);
3014         for (int i = 0; i < SIZE; i++) {
3015             Asserts.assertEquals(floatc[i], cmoveFEQforFConst(floata[i], floatb[i]));
3016             Asserts.assertEquals(doublec[i], cmoveDEQforDConst(doublea[i], doubleb[i]));
3017         }
3018 
3019         testCMoveFNEQforFConst(floata, floatb, floatc);
3020         testCMoveDNEQforDConst(doublea, doubleb, doublec);
3021         for (int i = 0; i < SIZE; i++) {
3022             Asserts.assertEquals(floatc[i], cmoveFNEQforFConst(floata[i], floatb[i]));
3023             Asserts.assertEquals(doublec[i], cmoveDNEQforDConst(doublea[i], doubleb[i]));
3024         }
3025 
3026         // Hand-unrolled (H2) examples:
3027         testCMoveFLTforFConstH2(floata, floatb, floatc);
3028         testCMoveDLTforDConstH2(doublea, doubleb, doublec);
3029         for (int i = 0; i < SIZE; i++) {
3030             Asserts.assertEquals(floatc[i], cmoveFLTforFConst(floata[i], floatb[i]));
3031             Asserts.assertEquals(doublec[i], cmoveDLTforDConst(doublea[i], doubleb[i]));
3032         }
3033 
3034         testCMoveFLEforFConstH2(floata, floatb, floatc);
3035         testCMoveDLEforDConstH2(doublea, doubleb, doublec);
3036         for (int i = 0; i < SIZE; i++) {
3037             Asserts.assertEquals(floatc[i], cmoveFLEforFConst(floata[i], floatb[i]));
3038             Asserts.assertEquals(doublec[i], cmoveDLEforDConst(doublea[i], doubleb[i]));
3039         }
3040 
3041         testCMoveFYYforFConstH2(floata, floatb, floatc);
3042         testCMoveDYYforDConstH2(doublea, doubleb, doublec);
3043         for (int i = 0; i < SIZE; i+=2) {
3044             Asserts.assertEquals(floatc[i+0], cmoveFLEforFConst(floata[i+0], floatb[i+0]));
3045             Asserts.assertEquals(doublec[i+0], cmoveDLEforDConst(doublea[i+0], doubleb[i+0]));
3046             Asserts.assertEquals(floatc[i+1], cmoveFLTforFConst(floata[i+1], floatb[i+1]));
3047             Asserts.assertEquals(doublec[i+1], cmoveDLTforDConst(doublea[i+1], doubleb[i+1]));
3048         }
3049 
3050         testCMoveFXXforFConstH2(floata, floatb, floatc);
3051         testCMoveDXXforDConstH2(doublea, doubleb, doublec);
3052         for (int i = 0; i < SIZE; i+=2) {
3053             Asserts.assertEquals(floatc[i+0], cmoveFLTforFConst(floata[i+0], floatb[i+0]));
3054             Asserts.assertEquals(doublec[i+0], cmoveDLTforDConst(doublea[i+0], doubleb[i+0]));
3055             Asserts.assertEquals(floatc[i+1], cmoveFLEforFConst(floata[i+1], floatb[i+1]));
3056             Asserts.assertEquals(doublec[i+1], cmoveDLEforDConst(doublea[i+1], doubleb[i+1]));
3057         }
3058     }
3059 
3060     @Warmup(0)
3061     @Run(test = {// Signed
3062                  //     I for I
3063                  "testCMoveIEQforI",
3064                  "testCMoveINEforI",
3065                  "testCMoveIGTforI",
3066                  "testCMoveIGEforI",
3067                  "testCMoveILTforI",
3068                  "testCMoveILEforI",
3069                  //     I for L
3070                  "testCMoveIEQforL",
3071                  "testCMoveINEforL",
3072                  "testCMoveIGTforL",
3073                  "testCMoveIGEforL",
3074                  "testCMoveILTforL",
3075                  "testCMoveILEforL",
3076                  //     I for F
3077                  "testCMoveIEQforF",
3078                  "testCMoveINEforF",
3079                  "testCMoveIGTforF",
3080                  "testCMoveIGEforF",
3081                  "testCMoveILTforF",
3082                  "testCMoveILEforF",
3083                  //     I for D
3084                  "testCMoveIEQforD",
3085                  "testCMoveINEforD",
3086                  "testCMoveIGTforD",
3087                  "testCMoveIGEforD",
3088                  "testCMoveILTforD",
3089                  "testCMoveILEforD",
3090                  //     L for I
3091                  "testCMoveLEQforI",
3092                  "testCMoveLNEforI",
3093                  "testCMoveLGTforI",
3094                  "testCMoveLGEforI",
3095                  "testCMoveLLTforI",
3096                  "testCMoveLLEforI",
3097                  //     L for L
3098                  "testCMoveLEQforL",
3099                  "testCMoveLNEforL",
3100                  "testCMoveLGTforL",
3101                  "testCMoveLGEforL",
3102                  "testCMoveLLTforL",
3103                  "testCMoveLLEforL",
3104                  //     L for F
3105                  "testCMoveLEQforF",
3106                  "testCMoveLNEforF",
3107                  "testCMoveLGTforF",
3108                  "testCMoveLGEforF",
3109                  "testCMoveLLTforF",
3110                  "testCMoveLLEforF",
3111                  //     L for D
3112                  "testCMoveLEQforD",
3113                  "testCMoveLNEforD",
3114                  "testCMoveLGTforD",
3115                  "testCMoveLGEforD",
3116                  "testCMoveLLTforD",
3117                  "testCMoveLLEforD",
3118                  // Unsigned
3119                  //     I for I
3120                  "testCMoveUIEQforI",
3121                  "testCMoveUINEforI",
3122                  "testCMoveUIGTforI",
3123                  "testCMoveUIGEforI",
3124                  "testCMoveUILTforI",
3125                  "testCMoveUILEforI",
3126                  //     I for L
3127                  "testCMoveUIEQforL",
3128                  "testCMoveUINEforL",
3129                  "testCMoveUIGTforL",
3130                  "testCMoveUIGEforL",
3131                  "testCMoveUILTforL",
3132                  "testCMoveUILEforL",
3133                  //     I for F
3134                  "testCMoveUIEQforF",
3135                  "testCMoveUINEforF",
3136                  "testCMoveUIGTforF",
3137                  "testCMoveUIGEforF",
3138                  "testCMoveUILTforF",
3139                  "testCMoveUILEforF",
3140                  //     I for D
3141                  "testCMoveUIEQforD",
3142                  "testCMoveUINEforD",
3143                  "testCMoveUIGTforD",
3144                  "testCMoveUIGEforD",
3145                  "testCMoveUILTforD",
3146                  "testCMoveUILEforD",
3147                  //     L for I
3148                  "testCMoveULEQforI",
3149                  "testCMoveULNEforI",
3150                  "testCMoveULGTforI",
3151                  "testCMoveULGEforI",
3152                  "testCMoveULLTforI",
3153                  "testCMoveULLEforI",
3154                  //     L for L
3155                  "testCMoveULEQforL",
3156                  "testCMoveULNEforL",
3157                  "testCMoveULGTforL",
3158                  "testCMoveULGEforL",
3159                  "testCMoveULLTforL",
3160                  "testCMoveULLEforL",
3161                  //     L for F
3162                  "testCMoveULEQforF",
3163                  "testCMoveULNEforF",
3164                  "testCMoveULGTforF",
3165                  "testCMoveULGEforF",
3166                  "testCMoveULLTforF",
3167                  "testCMoveULLEforF",
3168                  //     L for D
3169                  "testCMoveULEQforD",
3170                  "testCMoveULNEforD",
3171                  "testCMoveULGTforD",
3172                  "testCMoveULGEforD",
3173                  "testCMoveULLTforD",
3174                  "testCMoveULLEforD",
3175                  // Float
3176                  "testCMoveFGTforI",
3177                  "testCMoveFGTforL",
3178                  "testCMoveFGTforF",
3179                  "testCMoveFGTforD",
3180                  "testCMoveDGTforI",
3181                  "testCMoveDGTforL",
3182                  "testCMoveDGTforF",
3183                  "testCMoveDGTforD",
3184                  "testCMoveFGTforFCmpCon1",
3185                  "testCMoveFGTforFCmpCon2"})
3186     private void testCMove_runner_two() {
3187         int[] aI = new int[SIZE];
3188         int[] bI = new int[SIZE];
3189         int[] cI = new int[SIZE];
3190         int[] dI = new int[SIZE];
3191         int[] rI = new int[SIZE];
3192         long[] aL = new long[SIZE];
3193         long[] bL = new long[SIZE];
3194         long[] cL = new long[SIZE];
3195         long[] dL = new long[SIZE];
3196         long[] rL = new long[SIZE];
3197         float[] aF = new float[SIZE];
3198         float[] bF = new float[SIZE];
3199         float[] cF = new float[SIZE];
3200         float[] dF = new float[SIZE];
3201         float[] rF = new float[SIZE];
3202         double[] aD = new double[SIZE];
3203         double[] bD = new double[SIZE];
3204         double[] cD = new double[SIZE];
3205         double[] dD = new double[SIZE];
3206         double[] rD = new double[SIZE];
3207 
3208         init(aI);
3209         init(bI);
3210         init(cI);
3211         init(dI);
3212         init(aL);
3213         init(bL);
3214         init(cL);
3215         init(dL);
3216         init(aF);
3217         init(bF);
3218         init(cF);
3219         init(dF);
3220         init(aD);
3221         init(bD);
3222         init(cD);
3223         init(dD);
3224 
3225         // Signed
3226         //     I for I
3227         testCMoveIEQforI(aI, bI, cI, dI, rI, rI);
3228         for (int i = 0; i < SIZE; i++) {
3229             Asserts.assertEquals(rI[i], cmoveIEQforI(aI[i], bI[i], cI[i], dI[i]));
3230         }
3231 
3232         testCMoveINEforI(aI, bI, cI, dI, rI, rI);
3233         for (int i = 0; i < SIZE; i++) {
3234             Asserts.assertEquals(rI[i], cmoveINEforI(aI[i], bI[i], cI[i], dI[i]));
3235         }
3236 
3237         testCMoveIGTforI(aI, bI, cI, dI, rI, rI);
3238         for (int i = 0; i < SIZE; i++) {
3239             Asserts.assertEquals(rI[i], cmoveIGTforI(aI[i], bI[i], cI[i], dI[i]));
3240         }
3241 
3242         testCMoveIGEforI(aI, bI, cI, dI, rI, rI);
3243         for (int i = 0; i < SIZE; i++) {
3244             Asserts.assertEquals(rI[i], cmoveIGEforI(aI[i], bI[i], cI[i], dI[i]));
3245         }
3246 
3247         testCMoveILTforI(aI, bI, cI, dI, rI, rI);
3248         for (int i = 0; i < SIZE; i++) {
3249             Asserts.assertEquals(rI[i], cmoveILTforI(aI[i], bI[i], cI[i], dI[i]));
3250         }
3251 
3252         testCMoveILEforI(aI, bI, cI, dI, rI, rI);
3253         for (int i = 0; i < SIZE; i++) {
3254             Asserts.assertEquals(rI[i], cmoveILEforI(aI[i], bI[i], cI[i], dI[i]));
3255         }
3256 
3257         //     I for L
3258         testCMoveIEQforL(aI, bI, cL, dL, rL, rL);
3259         for (int i = 0; i < SIZE; i++) {
3260             Asserts.assertEquals(rL[i], cmoveIEQforL(aI[i], bI[i], cL[i], dL[i]));
3261         }
3262 
3263         testCMoveINEforL(aI, bI, cL, dL, rL, rL);
3264         for (int i = 0; i < SIZE; i++) {
3265             Asserts.assertEquals(rL[i], cmoveINEforL(aI[i], bI[i], cL[i], dL[i]));
3266         }
3267 
3268         testCMoveIGTforL(aI, bI, cL, dL, rL, rL);
3269         for (int i = 0; i < SIZE; i++) {
3270             Asserts.assertEquals(rL[i], cmoveIGTforL(aI[i], bI[i], cL[i], dL[i]));
3271         }
3272 
3273         testCMoveIGEforL(aI, bI, cL, dL, rL, rL);
3274         for (int i = 0; i < SIZE; i++) {
3275             Asserts.assertEquals(rL[i], cmoveIGEforL(aI[i], bI[i], cL[i], dL[i]));
3276         }
3277 
3278         testCMoveILTforL(aI, bI, cL, dL, rL, rL);
3279         for (int i = 0; i < SIZE; i++) {
3280             Asserts.assertEquals(rL[i], cmoveILTforL(aI[i], bI[i], cL[i], dL[i]));
3281         }
3282 
3283         testCMoveILEforL(aI, bI, cL, dL, rL, rL);
3284         for (int i = 0; i < SIZE; i++) {
3285             Asserts.assertEquals(rL[i], cmoveILEforL(aI[i], bI[i], cL[i], dL[i]));
3286         }
3287 
3288         //     I for F
3289         testCMoveIEQforF(aI, bI, cF, dF, rF, rF);
3290         for (int i = 0; i < SIZE; i++) {
3291             Asserts.assertEquals(rF[i], cmoveIEQforF(aI[i], bI[i], cF[i], dF[i]));
3292         }
3293 
3294         testCMoveINEforF(aI, bI, cF, dF, rF, rF);
3295         for (int i = 0; i < SIZE; i++) {
3296             Asserts.assertEquals(rF[i], cmoveINEforF(aI[i], bI[i], cF[i], dF[i]));
3297         }
3298 
3299         testCMoveIGTforF(aI, bI, cF, dF, rF, rF);
3300         for (int i = 0; i < SIZE; i++) {
3301             Asserts.assertEquals(rF[i], cmoveIGTforF(aI[i], bI[i], cF[i], dF[i]));
3302         }
3303 
3304         testCMoveIGEforF(aI, bI, cF, dF, rF, rF);
3305         for (int i = 0; i < SIZE; i++) {
3306             Asserts.assertEquals(rF[i], cmoveIGEforF(aI[i], bI[i], cF[i], dF[i]));
3307         }
3308 
3309         testCMoveILTforF(aI, bI, cF, dF, rF, rF);
3310         for (int i = 0; i < SIZE; i++) {
3311             Asserts.assertEquals(rF[i], cmoveILTforF(aI[i], bI[i], cF[i], dF[i]));
3312         }
3313 
3314         testCMoveILEforF(aI, bI, cF, dF, rF, rF);
3315         for (int i = 0; i < SIZE; i++) {
3316             Asserts.assertEquals(rF[i], cmoveILEforF(aI[i], bI[i], cF[i], dF[i]));
3317         }
3318 
3319         //     I for D
3320         testCMoveIEQforD(aI, bI, cD, dD, rD, rD);
3321         for (int i = 0; i < SIZE; i++) {
3322             Asserts.assertEquals(rD[i], cmoveIEQforD(aI[i], bI[i], cD[i], dD[i]));
3323         }
3324 
3325         testCMoveINEforD(aI, bI, cD, dD, rD, rD);
3326         for (int i = 0; i < SIZE; i++) {
3327             Asserts.assertEquals(rD[i], cmoveINEforD(aI[i], bI[i], cD[i], dD[i]));
3328         }
3329 
3330         testCMoveIGTforD(aI, bI, cD, dD, rD, rD);
3331         for (int i = 0; i < SIZE; i++) {
3332             Asserts.assertEquals(rD[i], cmoveIGTforD(aI[i], bI[i], cD[i], dD[i]));
3333         }
3334 
3335         testCMoveIGEforD(aI, bI, cD, dD, rD, rD);
3336         for (int i = 0; i < SIZE; i++) {
3337             Asserts.assertEquals(rD[i], cmoveIGEforD(aI[i], bI[i], cD[i], dD[i]));
3338         }
3339 
3340         testCMoveILTforD(aI, bI, cD, dD, rD, rD);
3341         for (int i = 0; i < SIZE; i++) {
3342             Asserts.assertEquals(rD[i], cmoveILTforD(aI[i], bI[i], cD[i], dD[i]));
3343         }
3344 
3345         testCMoveILEforD(aI, bI, cD, dD, rD, rD);
3346         for (int i = 0; i < SIZE; i++) {
3347             Asserts.assertEquals(rD[i], cmoveILEforD(aI[i], bI[i], cD[i], dD[i]));
3348         }
3349 
3350         //     L for I
3351         testCMoveLEQforI(aL, bL, cI, dI, rI, rI);
3352         for (int i = 0; i < SIZE; i++) {
3353             Asserts.assertEquals(rI[i], cmoveLEQforI(aL[i], bL[i], cI[i], dI[i]));
3354         }
3355 
3356         testCMoveLNEforI(aL, bL, cI, dI, rI, rI);
3357         for (int i = 0; i < SIZE; i++) {
3358             Asserts.assertEquals(rI[i], cmoveLNEforI(aL[i], bL[i], cI[i], dI[i]));
3359         }
3360 
3361         testCMoveLGTforI(aL, bL, cI, dI, rI, rI);
3362         for (int i = 0; i < SIZE; i++) {
3363             Asserts.assertEquals(rI[i], cmoveLGTforI(aL[i], bL[i], cI[i], dI[i]));
3364         }
3365 
3366         testCMoveLGEforI(aL, bL, cI, dI, rI, rI);
3367         for (int i = 0; i < SIZE; i++) {
3368             Asserts.assertEquals(rI[i], cmoveLGEforI(aL[i], bL[i], cI[i], dI[i]));
3369         }
3370 
3371         testCMoveLLTforI(aL, bL, cI, dI, rI, rI);
3372         for (int i = 0; i < SIZE; i++) {
3373             Asserts.assertEquals(rI[i], cmoveLLTforI(aL[i], bL[i], cI[i], dI[i]));
3374         }
3375 
3376         testCMoveLLEforI(aL, bL, cI, dI, rI, rI);
3377         for (int i = 0; i < SIZE; i++) {
3378             Asserts.assertEquals(rI[i], cmoveLLEforI(aL[i], bL[i], cI[i], dI[i]));
3379         }
3380 
3381         //     L for L
3382         testCMoveLEQforL(aL, bL, cL, dL, rL, rL);
3383         for (int i = 0; i < SIZE; i++) {
3384             Asserts.assertEquals(rL[i], cmoveLEQforL(aL[i], bL[i], cL[i], dL[i]));
3385         }
3386 
3387         testCMoveLNEforL(aL, bL, cL, dL, rL, rL);
3388         for (int i = 0; i < SIZE; i++) {
3389             Asserts.assertEquals(rL[i], cmoveLNEforL(aL[i], bL[i], cL[i], dL[i]));
3390         }
3391 
3392         testCMoveLGTforL(aL, bL, cL, dL, rL, rL);
3393         for (int i = 0; i < SIZE; i++) {
3394             Asserts.assertEquals(rL[i], cmoveLGTforL(aL[i], bL[i], cL[i], dL[i]));
3395         }
3396 
3397         testCMoveLGEforL(aL, bL, cL, dL, rL, rL);
3398         for (int i = 0; i < SIZE; i++) {
3399             Asserts.assertEquals(rL[i], cmoveLGEforL(aL[i], bL[i], cL[i], dL[i]));
3400         }
3401 
3402         testCMoveLLTforL(aL, bL, cL, dL, rL, rL);
3403         for (int i = 0; i < SIZE; i++) {
3404             Asserts.assertEquals(rL[i], cmoveLLTforL(aL[i], bL[i], cL[i], dL[i]));
3405         }
3406 
3407         testCMoveLLEforL(aL, bL, cL, dL, rL, rL);
3408         for (int i = 0; i < SIZE; i++) {
3409             Asserts.assertEquals(rL[i], cmoveLLEforL(aL[i], bL[i], cL[i], dL[i]));
3410         }
3411 
3412         //     L for F
3413         testCMoveLEQforF(aL, bL, cF, dF, rF, rF);
3414         for (int i = 0; i < SIZE; i++) {
3415             Asserts.assertEquals(rF[i], cmoveLEQforF(aL[i], bL[i], cF[i], dF[i]));
3416         }
3417 
3418         testCMoveLNEforF(aL, bL, cF, dF, rF, rF);
3419         for (int i = 0; i < SIZE; i++) {
3420             Asserts.assertEquals(rF[i], cmoveLNEforF(aL[i], bL[i], cF[i], dF[i]));
3421         }
3422 
3423         testCMoveLGTforF(aL, bL, cF, dF, rF, rF);
3424         for (int i = 0; i < SIZE; i++) {
3425             Asserts.assertEquals(rF[i], cmoveLGTforF(aL[i], bL[i], cF[i], dF[i]));
3426         }
3427 
3428         testCMoveLGEforF(aL, bL, cF, dF, rF, rF);
3429         for (int i = 0; i < SIZE; i++) {
3430             Asserts.assertEquals(rF[i], cmoveLGEforF(aL[i], bL[i], cF[i], dF[i]));
3431         }
3432 
3433         testCMoveLLTforF(aL, bL, cF, dF, rF, rF);
3434         for (int i = 0; i < SIZE; i++) {
3435             Asserts.assertEquals(rF[i], cmoveLLTforF(aL[i], bL[i], cF[i], dF[i]));
3436         }
3437 
3438         testCMoveLLEforF(aL, bL, cF, dF, rF, rF);
3439         for (int i = 0; i < SIZE; i++) {
3440             Asserts.assertEquals(rF[i], cmoveLLEforF(aL[i], bL[i], cF[i], dF[i]));
3441         }
3442 
3443         //     L for D
3444         testCMoveLEQforD(aL, bL, cD, dD, rD, rD);
3445         for (int i = 0; i < SIZE; i++) {
3446             Asserts.assertEquals(rD[i], cmoveLEQforD(aL[i], bL[i], cD[i], dD[i]));
3447         }
3448 
3449         testCMoveLNEforD(aL, bL, cD, dD, rD, rD);
3450         for (int i = 0; i < SIZE; i++) {
3451             Asserts.assertEquals(rD[i], cmoveLNEforD(aL[i], bL[i], cD[i], dD[i]));
3452         }
3453 
3454         testCMoveLGTforD(aL, bL, cD, dD, rD, rD);
3455         for (int i = 0; i < SIZE; i++) {
3456             Asserts.assertEquals(rD[i], cmoveLGTforD(aL[i], bL[i], cD[i], dD[i]));
3457         }
3458 
3459         testCMoveLGEforD(aL, bL, cD, dD, rD, rD);
3460         for (int i = 0; i < SIZE; i++) {
3461             Asserts.assertEquals(rD[i], cmoveLGEforD(aL[i], bL[i], cD[i], dD[i]));
3462         }
3463 
3464         testCMoveLLTforD(aL, bL, cD, dD, rD, rD);
3465         for (int i = 0; i < SIZE; i++) {
3466             Asserts.assertEquals(rD[i], cmoveLLTforD(aL[i], bL[i], cD[i], dD[i]));
3467         }
3468 
3469         testCMoveLLEforD(aL, bL, cD, dD, rD, rD);
3470         for (int i = 0; i < SIZE; i++) {
3471             Asserts.assertEquals(rD[i], cmoveLLEforD(aL[i], bL[i], cD[i], dD[i]));
3472         }
3473 
3474         // Unsigned
3475         //     I for I
3476         testCMoveUIEQforI(aI, bI, cI, dI, rI, rI);
3477         for (int i = 0; i < SIZE; i++) {
3478             Asserts.assertEquals(rI[i], cmoveUIEQforI(aI[i], bI[i], cI[i], dI[i]));
3479         }
3480 
3481         testCMoveUINEforI(aI, bI, cI, dI, rI, rI);
3482         for (int i = 0; i < SIZE; i++) {
3483             Asserts.assertEquals(rI[i], cmoveUINEforI(aI[i], bI[i], cI[i], dI[i]));
3484         }
3485 
3486         testCMoveUIGTforI(aI, bI, cI, dI, rI, rI);
3487         for (int i = 0; i < SIZE; i++) {
3488             Asserts.assertEquals(rI[i], cmoveUIGTforI(aI[i], bI[i], cI[i], dI[i]));
3489         }
3490 
3491         testCMoveUIGEforI(aI, bI, cI, dI, rI, rI);
3492         for (int i = 0; i < SIZE; i++) {
3493             Asserts.assertEquals(rI[i], cmoveUIGEforI(aI[i], bI[i], cI[i], dI[i]));
3494         }
3495 
3496         testCMoveUILTforI(aI, bI, cI, dI, rI, rI);
3497         for (int i = 0; i < SIZE; i++) {
3498             Asserts.assertEquals(rI[i], cmoveUILTforI(aI[i], bI[i], cI[i], dI[i]));
3499         }
3500 
3501         testCMoveUILEforI(aI, bI, cI, dI, rI, rI);
3502         for (int i = 0; i < SIZE; i++) {
3503             Asserts.assertEquals(rI[i], cmoveUILEforI(aI[i], bI[i], cI[i], dI[i]));
3504         }
3505 
3506         //     I for L
3507         testCMoveUIEQforL(aI, bI, cL, dL, rL, rL);
3508         for (int i = 0; i < SIZE; i++) {
3509             Asserts.assertEquals(rL[i], cmoveUIEQforL(aI[i], bI[i], cL[i], dL[i]));
3510         }
3511 
3512         testCMoveUINEforL(aI, bI, cL, dL, rL, rL);
3513         for (int i = 0; i < SIZE; i++) {
3514             Asserts.assertEquals(rL[i], cmoveUINEforL(aI[i], bI[i], cL[i], dL[i]));
3515         }
3516 
3517         testCMoveUIGTforL(aI, bI, cL, dL, rL, rL);
3518         for (int i = 0; i < SIZE; i++) {
3519             Asserts.assertEquals(rL[i], cmoveUIGTforL(aI[i], bI[i], cL[i], dL[i]));
3520         }
3521 
3522         testCMoveUIGEforL(aI, bI, cL, dL, rL, rL);
3523         for (int i = 0; i < SIZE; i++) {
3524             Asserts.assertEquals(rL[i], cmoveUIGEforL(aI[i], bI[i], cL[i], dL[i]));
3525         }
3526 
3527         testCMoveUILTforL(aI, bI, cL, dL, rL, rL);
3528         for (int i = 0; i < SIZE; i++) {
3529             Asserts.assertEquals(rL[i], cmoveUILTforL(aI[i], bI[i], cL[i], dL[i]));
3530         }
3531 
3532         testCMoveUILEforL(aI, bI, cL, dL, rL, rL);
3533         for (int i = 0; i < SIZE; i++) {
3534             Asserts.assertEquals(rL[i], cmoveUILEforL(aI[i], bI[i], cL[i], dL[i]));
3535         }
3536 
3537         //     I for F
3538         testCMoveUIEQforF(aI, bI, cF, dF, rF, rF);
3539         for (int i = 0; i < SIZE; i++) {
3540             Asserts.assertEquals(rF[i], cmoveUIEQforF(aI[i], bI[i], cF[i], dF[i]));
3541         }
3542 
3543         testCMoveUINEforF(aI, bI, cF, dF, rF, rF);
3544         for (int i = 0; i < SIZE; i++) {
3545             Asserts.assertEquals(rF[i], cmoveUINEforF(aI[i], bI[i], cF[i], dF[i]));
3546         }
3547 
3548         testCMoveUIGTforF(aI, bI, cF, dF, rF, rF);
3549         for (int i = 0; i < SIZE; i++) {
3550             Asserts.assertEquals(rF[i], cmoveUIGTforF(aI[i], bI[i], cF[i], dF[i]));
3551         }
3552 
3553         testCMoveUIGEforF(aI, bI, cF, dF, rF, rF);
3554         for (int i = 0; i < SIZE; i++) {
3555             Asserts.assertEquals(rF[i], cmoveUIGEforF(aI[i], bI[i], cF[i], dF[i]));
3556         }
3557 
3558         testCMoveUILTforF(aI, bI, cF, dF, rF, rF);
3559         for (int i = 0; i < SIZE; i++) {
3560             Asserts.assertEquals(rF[i], cmoveUILTforF(aI[i], bI[i], cF[i], dF[i]));
3561         }
3562 
3563         testCMoveUILEforF(aI, bI, cF, dF, rF, rF);
3564         for (int i = 0; i < SIZE; i++) {
3565             Asserts.assertEquals(rF[i], cmoveUILEforF(aI[i], bI[i], cF[i], dF[i]));
3566         }
3567 
3568         //     I for D
3569         testCMoveUIEQforD(aI, bI, cD, dD, rD, rD);
3570         for (int i = 0; i < SIZE; i++) {
3571             Asserts.assertEquals(rD[i], cmoveUIEQforD(aI[i], bI[i], cD[i], dD[i]));
3572         }
3573 
3574         testCMoveUINEforD(aI, bI, cD, dD, rD, rD);
3575         for (int i = 0; i < SIZE; i++) {
3576             Asserts.assertEquals(rD[i], cmoveUINEforD(aI[i], bI[i], cD[i], dD[i]));
3577         }
3578 
3579         testCMoveUIGTforD(aI, bI, cD, dD, rD, rD);
3580         for (int i = 0; i < SIZE; i++) {
3581             Asserts.assertEquals(rD[i], cmoveUIGTforD(aI[i], bI[i], cD[i], dD[i]));
3582         }
3583 
3584         testCMoveUIGEforD(aI, bI, cD, dD, rD, rD);
3585         for (int i = 0; i < SIZE; i++) {
3586             Asserts.assertEquals(rD[i], cmoveUIGEforD(aI[i], bI[i], cD[i], dD[i]));
3587         }
3588 
3589         testCMoveUILTforD(aI, bI, cD, dD, rD, rD);
3590         for (int i = 0; i < SIZE; i++) {
3591             Asserts.assertEquals(rD[i], cmoveUILTforD(aI[i], bI[i], cD[i], dD[i]));
3592         }
3593 
3594         testCMoveUILEforD(aI, bI, cD, dD, rD, rD);
3595         for (int i = 0; i < SIZE; i++) {
3596             Asserts.assertEquals(rD[i], cmoveUILEforD(aI[i], bI[i], cD[i], dD[i]));
3597         }
3598 
3599         //     L for I
3600         testCMoveULEQforI(aL, bL, cI, dI, rI, rI);
3601         for (int i = 0; i < SIZE; i++) {
3602             Asserts.assertEquals(rI[i], cmoveULEQforI(aL[i], bL[i], cI[i], dI[i]));
3603         }
3604 
3605         testCMoveULNEforI(aL, bL, cI, dI, rI, rI);
3606         for (int i = 0; i < SIZE; i++) {
3607             Asserts.assertEquals(rI[i], cmoveULNEforI(aL[i], bL[i], cI[i], dI[i]));
3608         }
3609 
3610         testCMoveULGTforI(aL, bL, cI, dI, rI, rI);
3611         for (int i = 0; i < SIZE; i++) {
3612             Asserts.assertEquals(rI[i], cmoveULGTforI(aL[i], bL[i], cI[i], dI[i]));
3613         }
3614 
3615         testCMoveULGEforI(aL, bL, cI, dI, rI, rI);
3616         for (int i = 0; i < SIZE; i++) {
3617             Asserts.assertEquals(rI[i], cmoveULGEforI(aL[i], bL[i], cI[i], dI[i]));
3618         }
3619 
3620         testCMoveULLTforI(aL, bL, cI, dI, rI, rI);
3621         for (int i = 0; i < SIZE; i++) {
3622             Asserts.assertEquals(rI[i], cmoveULLTforI(aL[i], bL[i], cI[i], dI[i]));
3623         }
3624 
3625         testCMoveULLEforI(aL, bL, cI, dI, rI, rI);
3626         for (int i = 0; i < SIZE; i++) {
3627             Asserts.assertEquals(rI[i], cmoveULLEforI(aL[i], bL[i], cI[i], dI[i]));
3628         }
3629 
3630         //     L for L
3631         testCMoveULEQforL(aL, bL, cL, dL, rL, rL);
3632         for (int i = 0; i < SIZE; i++) {
3633             Asserts.assertEquals(rL[i], cmoveULEQforL(aL[i], bL[i], cL[i], dL[i]));
3634         }
3635 
3636         testCMoveULNEforL(aL, bL, cL, dL, rL, rL);
3637         for (int i = 0; i < SIZE; i++) {
3638             Asserts.assertEquals(rL[i], cmoveULNEforL(aL[i], bL[i], cL[i], dL[i]));
3639         }
3640 
3641         testCMoveULGTforL(aL, bL, cL, dL, rL, rL);
3642         for (int i = 0; i < SIZE; i++) {
3643             Asserts.assertEquals(rL[i], cmoveULGTforL(aL[i], bL[i], cL[i], dL[i]));
3644         }
3645 
3646         testCMoveULGEforL(aL, bL, cL, dL, rL, rL);
3647         for (int i = 0; i < SIZE; i++) {
3648             Asserts.assertEquals(rL[i], cmoveULGEforL(aL[i], bL[i], cL[i], dL[i]));
3649         }
3650 
3651         testCMoveULLTforL(aL, bL, cL, dL, rL, rL);
3652         for (int i = 0; i < SIZE; i++) {
3653             Asserts.assertEquals(rL[i], cmoveULLTforL(aL[i], bL[i], cL[i], dL[i]));
3654         }
3655 
3656         testCMoveULLEforL(aL, bL, cL, dL, rL, rL);
3657         for (int i = 0; i < SIZE; i++) {
3658             Asserts.assertEquals(rL[i], cmoveULLEforL(aL[i], bL[i], cL[i], dL[i]));
3659         }
3660 
3661         //     L for F
3662         testCMoveULEQforF(aL, bL, cF, dF, rF, rF);
3663         for (int i = 0; i < SIZE; i++) {
3664             Asserts.assertEquals(rF[i], cmoveULEQforF(aL[i], bL[i], cF[i], dF[i]));
3665         }
3666 
3667         testCMoveULNEforF(aL, bL, cF, dF, rF, rF);
3668         for (int i = 0; i < SIZE; i++) {
3669             Asserts.assertEquals(rF[i], cmoveULNEforF(aL[i], bL[i], cF[i], dF[i]));
3670         }
3671 
3672         testCMoveULGTforF(aL, bL, cF, dF, rF, rF);
3673         for (int i = 0; i < SIZE; i++) {
3674             Asserts.assertEquals(rF[i], cmoveULGTforF(aL[i], bL[i], cF[i], dF[i]));
3675         }
3676 
3677         testCMoveULGEforF(aL, bL, cF, dF, rF, rF);
3678         for (int i = 0; i < SIZE; i++) {
3679             Asserts.assertEquals(rF[i], cmoveULGEforF(aL[i], bL[i], cF[i], dF[i]));
3680         }
3681 
3682         testCMoveULLTforF(aL, bL, cF, dF, rF, rF);
3683         for (int i = 0; i < SIZE; i++) {
3684             Asserts.assertEquals(rF[i], cmoveULLTforF(aL[i], bL[i], cF[i], dF[i]));
3685         }
3686 
3687         testCMoveULLEforF(aL, bL, cF, dF, rF, rF);
3688         for (int i = 0; i < SIZE; i++) {
3689             Asserts.assertEquals(rF[i], cmoveULLEforF(aL[i], bL[i], cF[i], dF[i]));
3690         }
3691 
3692         //     L for D
3693         testCMoveULEQforD(aL, bL, cD, dD, rD, rD);
3694         for (int i = 0; i < SIZE; i++) {
3695             Asserts.assertEquals(rD[i], cmoveULEQforD(aL[i], bL[i], cD[i], dD[i]));
3696         }
3697 
3698         testCMoveULNEforD(aL, bL, cD, dD, rD, rD);
3699         for (int i = 0; i < SIZE; i++) {
3700             Asserts.assertEquals(rD[i], cmoveULNEforD(aL[i], bL[i], cD[i], dD[i]));
3701         }
3702 
3703         testCMoveULGTforD(aL, bL, cD, dD, rD, rD);
3704         for (int i = 0; i < SIZE; i++) {
3705             Asserts.assertEquals(rD[i], cmoveULGTforD(aL[i], bL[i], cD[i], dD[i]));
3706         }
3707 
3708         testCMoveULGEforD(aL, bL, cD, dD, rD, rD);
3709         for (int i = 0; i < SIZE; i++) {
3710             Asserts.assertEquals(rD[i], cmoveULGEforD(aL[i], bL[i], cD[i], dD[i]));
3711         }
3712 
3713         testCMoveULLTforD(aL, bL, cD, dD, rD, rD);
3714         for (int i = 0; i < SIZE; i++) {
3715             Asserts.assertEquals(rD[i], cmoveULLTforD(aL[i], bL[i], cD[i], dD[i]));
3716         }
3717 
3718         testCMoveULLEforD(aL, bL, cD, dD, rD, rD);
3719         for (int i = 0; i < SIZE; i++) {
3720             Asserts.assertEquals(rD[i], cmoveULLEforD(aL[i], bL[i], cD[i], dD[i]));
3721         }
3722 
3723         // Float
3724         testCMoveFGTforI(aF, bF, cI, dI, rI, rI);
3725         for (int i = 0; i < SIZE; i++) {
3726             Asserts.assertEquals(rI[i], cmoveFGTforI(aF[i], bF[i], cI[i], dI[i]));
3727         }
3728 
3729         testCMoveFGTforL(aF, bF, cL, dL, rL, rL);
3730         for (int i = 0; i < SIZE; i++) {
3731             Asserts.assertEquals(rL[i], cmoveFGTforL(aF[i], bF[i], cL[i], dL[i]));
3732         }
3733 
3734         testCMoveFGTforF(aF, bF, cF, dF, rF, rF);
3735         for (int i = 0; i < SIZE; i++) {
3736             Asserts.assertEquals(rF[i], cmoveFGTforF(aF[i], bF[i], cF[i], dF[i]));
3737         }
3738 
3739         testCMoveFGTforD(aF, bF, cD, dD, rD, rD);
3740         for (int i = 0; i < SIZE; i++) {
3741             Asserts.assertEquals(rD[i], cmoveFGTforD(aF[i], bF[i], cD[i], dD[i]));
3742         }
3743 
3744         testCMoveDGTforI(aD, bD, cI, dI, rI, rI);
3745         for (int i = 0; i < SIZE; i++) {
3746             Asserts.assertEquals(rI[i], cmoveDGTforI(aD[i], bD[i], cI[i], dI[i]));
3747         }
3748 
3749         testCMoveDGTforL(aD, bD, cL, dL, rL, rL);
3750         for (int i = 0; i < SIZE; i++) {
3751             Asserts.assertEquals(rL[i], cmoveDGTforL(aD[i], bD[i], cL[i], dL[i]));
3752         }
3753 
3754         testCMoveDGTforF(aD, bD, cF, dF, rF, rF);
3755         for (int i = 0; i < SIZE; i++) {
3756             Asserts.assertEquals(rF[i], cmoveDGTforF(aD[i], bD[i], cF[i], dF[i]));
3757         }
3758 
3759         testCMoveDGTforD(aD, bD, cD, dD, rD, rD);
3760         for (int i = 0; i < SIZE; i++) {
3761             Asserts.assertEquals(rD[i], cmoveDGTforD(aD[i], bD[i], cD[i], dD[i]));
3762         }
3763 
3764         // Use some constants/invariants in the comparison
3765         testCMoveFGTforFCmpCon1(aF[0], bF, cF, dF, rF, rF);
3766         for (int i = 0; i < SIZE; i++) {
3767             Asserts.assertEquals(rF[i], cmoveFGTforF(aF[0], bF[i], cF[i], dF[i]));
3768         }
3769 
3770         testCMoveFGTforFCmpCon2(aF, bF[0], cF, dF, rF, rF);
3771         for (int i = 0; i < SIZE; i++) {
3772             Asserts.assertEquals(rF[i], cmoveFGTforF(aF[i], bF[0], cF[i], dF[i]));
3773         }
3774     }
3775 
3776     private static void init(int[] a) {
3777         for (int i = 0; i < SIZE; i++) {
3778             a[i] = RANDOM.nextInt();
3779         }
3780     }
3781 
3782     private static void init(long[] a) {
3783         for (int i = 0; i < SIZE; i++) {
3784             a[i] = RANDOM.nextLong();
3785         }
3786     }
3787 
3788     private static void init(float[] a) {
3789         for (int i = 0; i < SIZE; i++) {
3790             a[i] = switch(RANDOM.nextInt() % 20) {
3791                 case 0  -> Float.NaN;
3792                 case 1  -> 0;
3793                 case 2  -> 1;
3794                 case 3  -> Float.POSITIVE_INFINITY;
3795                 case 4  -> Float.NEGATIVE_INFINITY;
3796                 case 5  -> Float.MAX_VALUE;
3797                 case 6  -> Float.MIN_VALUE;
3798                 case 7, 8, 9 -> RANDOM.nextFloat();
3799                 default -> Float.intBitsToFloat(RANDOM.nextInt());
3800             };
3801         }
3802     }
3803 
3804     private static void init(double[] a) {
3805         for (int i = 0; i < SIZE; i++) {
3806             a[i] = switch(RANDOM.nextInt() % 20) {
3807                 case 0  -> Double.NaN;
3808                 case 1  -> 0;
3809                 case 2  -> 1;
3810                 case 3  -> Double.POSITIVE_INFINITY;
3811                 case 4  -> Double.NEGATIVE_INFINITY;
3812                 case 5  -> Double.MAX_VALUE;
3813                 case 6  -> Double.MIN_VALUE;
3814                 case 7, 8, 9 -> RANDOM.nextDouble();
3815                 default -> Double.longBitsToDouble(RANDOM.nextLong());
3816             };
3817         }
3818     }
3819 }
--- EOF ---