1 /*
   2  * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 package compiler.lib.ir_framework;
  25 
  26 import compiler.lib.ir_framework.driver.irmatching.mapping.*;
  27 import compiler.lib.ir_framework.driver.irmatching.parser.VMInfo;
  28 import compiler.lib.ir_framework.shared.CheckedTestFrameworkException;
  29 import compiler.lib.ir_framework.shared.TestFormat;
  30 import compiler.lib.ir_framework.shared.TestFormatException;
  31 import compiler.valhalla.inlinetypes.InlineTypeIRNode;
  32 import jdk.test.lib.Platform;
  33 import jdk.test.whitebox.WhiteBox;
  34 
  35 import java.util.HashMap;
  36 import java.util.Map;
  37 
  38 /**
  39  * This class specifies IR node placeholder strings (also referred to as just "IR nodes") with mappings to regexes
  40  * depending on the selected compile phases. The mappings are stored in {@link #IR_NODE_MAPPINGS}. Each IR node
  41  * placeholder string is mapped to a {@link IRNodeMapEntry} instance defined in
  42  * {@link compiler.lib.ir_framework.driver.irmatching.mapping}.
  43  *
  44  * <p>
  45  * IR node placeholder strings can be used in {@link IR#failOn()} and/or {@link IR#counts()} attributes to define IR
  46  * constraints. They usually represent a single C2 IR node or a group of them.
  47  *
  48  * <p>
  49  * Each IR node placeholder string is accompanied by a static block that defines an IR node placeholder to regex(es)
  50  * mapping. The IR framework will automatically replace each IR node placeholder string in a user defined test with a
  51  * regex depending on the selected compile phases in {@link IR#phase} and the provided mapping.
  52  *
  53  * <p>
  54  * Each mapping must define a default compile phase which is applied when the user does not explicitly set the
  55  * {@link IR#phase()} attribute or when directly using {@link CompilePhase#DEFAULT}. In this case, the IR framework
  56  * falls back on the default compile phase of any {@link IRNodeMapEntry}.
  57  *
  58  * <p>
  59  * The IR framework reports a {@link TestFormatException} if:
  60  * <ul>
  61  *     <li><p> A user test specifies a compile phase for which no mapping is defined in this class.</li>
  62  *     <li><p> An IR node placeholder string is either missing a mapping or does not provide a regex for a specified
  63  *             compile phase in {@link IR#phase}.
  64  * </ul>
  65  *
  66  * <p>
  67  * There are two types of IR nodes:
  68  * <ul>
  69  *     <li><p>Normal IR nodes: The IR node placeholder string is directly replaced by a regex.</li>
  70  *     <li><p>Composite IR nodes:  The IR node placeholder string contains an additional {@link #COMPOSITE_PREFIX}.
  71  *                                 Using this IR node expects another user provided string in the constraint list of
  72  *                                 {@link IR#failOn()} and {@link IR#counts()}. They cannot be used as normal IR nodes.
  73  *                                 Trying to do so will result in a format violation error.</li>
  74  *     <li><p>Vector IR nodes:  The IR node placeholder string contains an additional {@link #VECTOR_PREFIX}.
  75  *                              Using this IR node, one can check for the type and size of a vector. The type must
  76  *                              be directly specified in {@link #vectorNode}. The size can be specified directly with
  77  *                              an additional argument using {@link #VECTOR_SIZE}, followed by a size tag or a comma
  78  *                              separated list of sizes. If the size argument is not given, then a default size of
  79  *                              {@link #VECTOR_SIZE_MAX} is taken, which is the number of elements that can fit in a
  80  *                              vector of the specified type (depends on the VM flag MaxVectorSize and CPU features).
  81  *                              However, when using {@link IR#failOn} or {@link IR#counts()} with comparison {@code <},
  82  *                              or {@code <=} or {@code =0}, the default size is {@link #VECTOR_SIZE_ANY}, allowing any
  83  *                              size. The motivation for these default values is that in most cases one wants to have
  84  *                              vectorization with maximal vector width, or no vectorization of any vector width.
  85  * </ul>
  86  */
  87 public class IRNode {
  88     /**
  89      * Prefix for normal IR nodes.
  90      */
  91     private static final String PREFIX = "_#";
  92     /**
  93      * Prefix for composite IR nodes.
  94      */
  95     private static final String COMPOSITE_PREFIX = PREFIX + "C#";
  96     /**
  97      * Prefix for vector IR nodes.
  98      */
  99     private static final String VECTOR_PREFIX = PREFIX + "V#";
 100 
 101     private static final String POSTFIX = "#_";
 102 
 103     private static final String START = "(\\d+(\\s){2}(";
 104     private static final String MID = ".*)+(\\s){2}===.*";
 105     private static final String END = ")";
 106     private static final String STORE_OF_CLASS_POSTFIX = "(:|\\+)\\S* \\*" + END;
 107     private static final String LOAD_OF_CLASS_POSTFIX = "(:|\\+)\\S* \\*" + END;
 108 
 109     public static final String IS_REPLACED = "#IS_REPLACED#"; // Is replaced by an additional user-defined string.
 110 
 111     public static final String VECTOR_SIZE = "_@";
 112     public static final String VECTOR_SIZE_TAG_ANY = "any";
 113     public static final String VECTOR_SIZE_TAG_MAX = "max_for_type";
 114     public static final String VECTOR_SIZE_ANY = VECTOR_SIZE + VECTOR_SIZE_TAG_ANY; // default for counts "=0" and failOn
 115     public static final String VECTOR_SIZE_MAX = VECTOR_SIZE + VECTOR_SIZE_TAG_MAX; // default in counts
 116     public static final String VECTOR_SIZE_2   = VECTOR_SIZE + "2";
 117     public static final String VECTOR_SIZE_4   = VECTOR_SIZE + "4";
 118     public static final String VECTOR_SIZE_8   = VECTOR_SIZE + "8";
 119     public static final String VECTOR_SIZE_16  = VECTOR_SIZE + "16";
 120     public static final String VECTOR_SIZE_32  = VECTOR_SIZE + "32";
 121     public static final String VECTOR_SIZE_64  = VECTOR_SIZE + "64";
 122 
 123     private static final String TYPE_BYTE   = "B";
 124     private static final String TYPE_CHAR   = "C";
 125     private static final String TYPE_SHORT  = "S";
 126     private static final String TYPE_INT    = "I";
 127     private static final String TYPE_LONG   = "J";
 128     private static final String TYPE_FLOAT  = "F";
 129     private static final String TYPE_DOUBLE = "D";
 130 
 131     /**
 132      * IR placeholder string to regex-for-compile-phase map.
 133      */
 134     private static final Map<String, IRNodeMapEntry> IR_NODE_MAPPINGS = new HashMap<>();
 135 
 136     /**
 137      * Map every vectorNode to a type string.
 138      */
 139     private static final Map<String, String> VECTOR_NODE_TYPE = new HashMap<>();
 140 
 141     /*
 142      * Start of IR placeholder string definitions followed by a static block defining the regex-for-compile-phase mapping.
 143      * An IR node placeholder string must start with PREFIX for normal IR nodes or COMPOSITE_PREFIX for composite IR
 144      * nodes, or VECTOR_PREFIX for vector nodes (see class description above).
 145      *
 146      * An IR node definition looks like this:
 147      *
 148      * public static final String IR_NODE = [PREFIX|COMPOSITE_PREFIX|VECTOR_PREFIX] + "IR_NODE" + POSTFIX;
 149      * static {
 150      *    // Define IR_NODE to regex-for-compile-phase mapping. Create a new IRNodeMapEntry object and add it to
 151      *    // IR_NODE_MAPPINGS. This can be done by using the helper methods defined after all IR node placeholder string
 152      *    // definitions.
 153      * }
 154      */
 155 
 156     // Valhalla: Make sure that all Valhalla specific IR nodes are also properly initialized. Doing it here also
 157     //           ensures that the Flag VM is able to pick up the correct compile phases.
 158     static {
 159         InlineTypeIRNode.forceStaticInitialization();
 160     }
 161 
 162     public static final String ABS_D = PREFIX + "ABS_D" + POSTFIX;
 163     static {
 164         beforeMatchingNameRegex(ABS_D, "AbsD");
 165     }
 166 
 167     public static final String ABS_F = PREFIX + "ABS_F" + POSTFIX;
 168     static {
 169         beforeMatchingNameRegex(ABS_F, "AbsF");
 170     }
 171 
 172     public static final String ABS_I = PREFIX + "ABS_I" + POSTFIX;
 173     static {
 174         beforeMatchingNameRegex(ABS_I, "AbsI");
 175     }
 176 
 177     public static final String ABS_L = PREFIX + "ABS_L" + POSTFIX;
 178     static {
 179         beforeMatchingNameRegex(ABS_L, "AbsL");
 180     }
 181 
 182     public static final String ABS_VB = VECTOR_PREFIX + "ABS_VB" + POSTFIX;
 183     static {
 184         vectorNode(ABS_VB, "AbsVB", TYPE_BYTE);
 185     }
 186 
 187     // ABS_VC / AbsVC does not exist (char is 2 byte unsigned)
 188 
 189     public static final String ABS_VS = VECTOR_PREFIX + "ABS_VS" + POSTFIX;
 190     static {
 191         vectorNode(ABS_VS, "AbsVS", TYPE_SHORT);
 192     }
 193 
 194     public static final String ABS_VI = VECTOR_PREFIX + "ABS_VI" + POSTFIX;
 195     static {
 196         vectorNode(ABS_VI, "AbsVI", TYPE_INT);
 197     }
 198 
 199     public static final String ABS_VL = VECTOR_PREFIX + "ABS_VL" + POSTFIX;
 200     static {
 201         vectorNode(ABS_VL, "AbsVL", TYPE_LONG);
 202     }
 203 
 204     public static final String ABS_VF = VECTOR_PREFIX + "ABS_VF" + POSTFIX;
 205     static {
 206         vectorNode(ABS_VF, "AbsVF", TYPE_FLOAT);
 207     }
 208 
 209     public static final String ABS_VD = VECTOR_PREFIX + "ABS_VD" + POSTFIX;
 210     static {
 211         vectorNode(ABS_VD, "AbsVD", TYPE_DOUBLE);
 212     }
 213 
 214     public static final String ADD = PREFIX + "ADD" + POSTFIX;
 215     static {
 216         beforeMatchingNameRegex(ADD, "Add(I|L|F|D|P)");
 217     }
 218 
 219     public static final String ADD_F = PREFIX + "ADD_F" + POSTFIX;
 220     static {
 221         beforeMatchingNameRegex(ADD_F, "AddF");
 222     }
 223 
 224     public static final String ADD_I = PREFIX + "ADD_I" + POSTFIX;
 225     static {
 226         beforeMatchingNameRegex(ADD_I, "AddI");
 227     }
 228 
 229     public static final String ADD_L = PREFIX + "ADD_L" + POSTFIX;
 230     static {
 231         beforeMatchingNameRegex(ADD_L, "AddL");
 232     }
 233 
 234     public static final String ADD_HF = PREFIX + "ADD_HF" + POSTFIX;
 235     static {
 236         beforeMatchingNameRegex(ADD_HF, "AddHF");
 237     }
 238 
 239     public static final String ADD_P = PREFIX + "ADD_P" + POSTFIX;
 240     static {
 241         beforeMatchingNameRegex(ADD_P, "AddP");
 242     }
 243 
 244     public static final String ADD_VD = VECTOR_PREFIX + "ADD_VD" + POSTFIX;
 245     static {
 246         vectorNode(ADD_VD, "AddVD", TYPE_DOUBLE);
 247     }
 248 
 249     public static final String ADD_VI = VECTOR_PREFIX + "ADD_VI" + POSTFIX;
 250     static {
 251         vectorNode(ADD_VI, "AddVI", TYPE_INT);
 252     }
 253 
 254     public static final String ADD_VHF = VECTOR_PREFIX + "ADD_VHF" + POSTFIX;
 255     static {
 256         vectorNode(ADD_VHF, "AddVHF", TYPE_SHORT);
 257     }
 258 
 259     public static final String ADD_VF = VECTOR_PREFIX + "ADD_VF" + POSTFIX;
 260     static {
 261         vectorNode(ADD_VF, "AddVF", TYPE_FLOAT);
 262     }
 263 
 264     public static final String ADD_VB = VECTOR_PREFIX + "ADD_VB" + POSTFIX;
 265     static {
 266         vectorNode(ADD_VB, "AddVB", TYPE_BYTE);
 267     }
 268 
 269     public static final String ADD_VS = VECTOR_PREFIX + "ADD_VS" + POSTFIX;
 270     static {
 271         vectorNode(ADD_VS, "AddVS", TYPE_SHORT);
 272     }
 273 
 274     public static final String ADD_VL = VECTOR_PREFIX + "ADD_VL" + POSTFIX;
 275     static {
 276         vectorNode(ADD_VL, "AddVL", TYPE_LONG);
 277     }
 278 
 279     public static final String SATURATING_ADD_VB = VECTOR_PREFIX + "SATURATING_ADD_VB" + POSTFIX;
 280     static {
 281         vectorNode(SATURATING_ADD_VB, "SaturatingAddV", TYPE_BYTE);
 282     }
 283 
 284     public static final String SATURATING_ADD_VS = VECTOR_PREFIX + "SATURATING_ADD_VS" + POSTFIX;
 285     static {
 286         vectorNode(SATURATING_ADD_VS, "SaturatingAddV", TYPE_SHORT);
 287     }
 288 
 289     public static final String SATURATING_ADD_VI = VECTOR_PREFIX + "SATURATING_ADD_VI" + POSTFIX;
 290     static {
 291         vectorNode(SATURATING_ADD_VI, "SaturatingAddV", TYPE_INT);
 292     }
 293 
 294     public static final String SATURATING_ADD_VL = VECTOR_PREFIX + "SATURATING_ADD_VL" + POSTFIX;
 295     static {
 296         vectorNode(SATURATING_ADD_VL, "SaturatingAddV", TYPE_LONG);
 297     }
 298 
 299     public static final String SATURATING_SUB_VB = VECTOR_PREFIX + "SATURATING_SUB_VB" + POSTFIX;
 300     static {
 301         vectorNode(SATURATING_SUB_VB, "SaturatingSubV", TYPE_BYTE);
 302     }
 303 
 304     public static final String SATURATING_SUB_VS = VECTOR_PREFIX + "SATURATING_SUB_VS" + POSTFIX;
 305     static {
 306         vectorNode(SATURATING_SUB_VS, "SaturatingSubV", TYPE_SHORT);
 307     }
 308 
 309     public static final String SATURATING_SUB_VI = VECTOR_PREFIX + "SATURATING_SUB_VI" + POSTFIX;
 310     static {
 311         vectorNode(SATURATING_SUB_VI, "SaturatingSubV", TYPE_INT);
 312     }
 313 
 314     public static final String SATURATING_SUB_VL = VECTOR_PREFIX + "SATURATING_SUB_VL" + POSTFIX;
 315     static {
 316         vectorNode(SATURATING_SUB_VL, "SaturatingSubV", TYPE_LONG);
 317     }
 318 
 319     public static final String ADD_REDUCTION_V = PREFIX + "ADD_REDUCTION_V" + POSTFIX;
 320     static {
 321         beforeMatchingNameRegex(ADD_REDUCTION_V, "AddReductionV(B|S|I|L|F|D)");
 322     }
 323 
 324     public static final String ADD_REDUCTION_VD = PREFIX + "ADD_REDUCTION_VD" + POSTFIX;
 325     static {
 326         superWordNodes(ADD_REDUCTION_VD, "AddReductionVD");
 327     }
 328 
 329     public static final String ADD_REDUCTION_VF = PREFIX + "ADD_REDUCTION_VF" + POSTFIX;
 330     static {
 331         superWordNodes(ADD_REDUCTION_VF, "AddReductionVF");
 332     }
 333 
 334     public static final String ADD_REDUCTION_VI = PREFIX + "ADD_REDUCTION_VI" + POSTFIX;
 335     static {
 336         superWordNodes(ADD_REDUCTION_VI, "AddReductionVI");
 337     }
 338 
 339     public static final String ADD_REDUCTION_VL = PREFIX + "ADD_REDUCTION_VL" + POSTFIX;
 340     static {
 341         superWordNodes(ADD_REDUCTION_VL, "AddReductionVL");
 342     }
 343 
 344     public static final String OPAQUE_MULTIVERSIONING = PREFIX + "OPAQUE_MULTIVERSIONING" + POSTFIX;
 345     static {
 346         beforeMatchingNameRegex(OPAQUE_MULTIVERSIONING, "OpaqueMultiversioning");
 347     }
 348 
 349     public static final String REARRANGE_VB = VECTOR_PREFIX + "REARRANGE_VB" + POSTFIX;
 350     static {
 351         vectorNode(REARRANGE_VB, "VectorRearrange", TYPE_BYTE);
 352     }
 353 
 354     public static final String REARRANGE_VS = VECTOR_PREFIX + "REARRANGE_VS" + POSTFIX;
 355     static {
 356         vectorNode(REARRANGE_VS, "VectorRearrange", TYPE_SHORT);
 357     }
 358 
 359     public static final String REARRANGE_VI = VECTOR_PREFIX + "REARRANGE_VI" + POSTFIX;
 360     static {
 361         vectorNode(REARRANGE_VI, "VectorRearrange", TYPE_INT);
 362     }
 363 
 364     public static final String REARRANGE_VL = VECTOR_PREFIX + "REARRANGE_VL" + POSTFIX;
 365     static {
 366         vectorNode(REARRANGE_VL, "VectorRearrange", TYPE_LONG);
 367     }
 368 
 369     public static final String REARRANGE_VF = VECTOR_PREFIX + "REARRANGE_VF" + POSTFIX;
 370     static {
 371         vectorNode(REARRANGE_VF, "VectorRearrange", TYPE_FLOAT);
 372     }
 373 
 374     public static final String REARRANGE_VD = VECTOR_PREFIX + "REARRANGE_VD" + POSTFIX;
 375     static {
 376         vectorNode(REARRANGE_VD, "VectorRearrange", TYPE_DOUBLE);
 377     }
 378 
 379     public static final String ADD_P_OF = COMPOSITE_PREFIX + "ADD_P_OF" + POSTFIX;
 380     static {
 381         String regex = START + "addP_" + IS_REPLACED + MID + ".*" + END;
 382         machOnly(ADD_P_OF, regex);
 383     }
 384 
 385     public static final String ALLOC = PREFIX + "ALLOC" + POSTFIX;
 386     static {
 387         String regex = START + "Allocate\\b" + MID + END;
 388         macroNodes(ALLOC, regex);
 389     }
 390 
 391     public static final String ALLOC_OF = COMPOSITE_PREFIX + "ALLOC_OF" + POSTFIX;
 392     static {
 393         String regex = START + "Allocate\\b" + MID + "allocationKlass:.*\\b" + IS_REPLACED + "\\s.*" + END;
 394         macroNodes(ALLOC_OF, regex);
 395     }
 396 
 397     public static final String ALLOC_ARRAY = PREFIX + "ALLOC_ARRAY" + POSTFIX;
 398     static {
 399         String regex = START + "AllocateArray\\b" + MID + END;
 400         macroNodes(ALLOC_ARRAY,  regex);
 401     }
 402 
 403     public static final String ALLOC_ARRAY_OF = COMPOSITE_PREFIX + "ALLOC_ARRAY_OF" + POSTFIX;
 404     static {
 405         // Assuming we are looking for an array of "some/package/MyClass". The printout is
 406         // [Lsome/package/MyClass;
 407         // or, with more dimensions
 408         // [[[Lsome/package/MyClass;
 409 
 410         // Case where the searched string is a not fully qualified name (but maybe partially qualified):
 411         // package/MyClass or MyClass
 412         // The ".*\\b" will eat the "some/" and "some/package/" resp.
 413         String partial_name_prefix = ".+\\b";
 414 
 415         // The thing after "allocationKlass:" (the name of the allocated class) is a sequence of:
 416         // - a non-empty sequence of "["
 417         // - a single character ("L"),
 418         // - maybe a non-empty sequence of characters ending on a word boundary
 419         //   this sequence is omitted if the given name is already fully qualified (exact match)
 420         //   but will eat the package path prefix in the cases described above
 421         // - the name we are looking for
 422         // - the final ";".
 423         String name_part = "\\[+.(" + partial_name_prefix + ")?" + IS_REPLACED + ";";
 424         String regex = START + "AllocateArray\\b" + MID + "allocationKlass:" + name_part + ".*" + END;
 425         macroNodes(ALLOC_ARRAY_OF, regex);
 426     }
 427 
 428     public static final String OR = PREFIX + "OR" + POSTFIX;
 429     static {
 430         beforeMatchingNameRegex(OR, "Or(I|L)");
 431     }
 432 
 433     public static final String AND = PREFIX + "AND" + POSTFIX;
 434     static {
 435         beforeMatchingNameRegex(AND, "And(I|L)");
 436     }
 437 
 438     public static final String AND_I = PREFIX + "AND_I" + POSTFIX;
 439     static {
 440         beforeMatchingNameRegex(AND_I, "AndI");
 441     }
 442 
 443     public static final String AND_L = PREFIX + "AND_L" + POSTFIX;
 444     static {
 445         beforeMatchingNameRegex(AND_L, "AndL");
 446     }
 447 
 448     public static final String AND_VB = VECTOR_PREFIX + "AND_VB" + POSTFIX;
 449     static {
 450         vectorNode(AND_VB, "AndV", TYPE_BYTE);
 451     }
 452 
 453     public static final String AND_VC = VECTOR_PREFIX + "AND_VC" + POSTFIX;
 454     static {
 455         vectorNode(AND_VC, "AndV", TYPE_CHAR);
 456     }
 457 
 458     public static final String AND_VS = VECTOR_PREFIX + "AND_VS" + POSTFIX;
 459     static {
 460         vectorNode(AND_VS, "AndV", TYPE_SHORT);
 461     }
 462 
 463     public static final String AND_VI = VECTOR_PREFIX + "AND_VI" + POSTFIX;
 464     static {
 465         vectorNode(AND_VI, "AndV", TYPE_INT);
 466     }
 467 
 468     public static final String AND_VL = VECTOR_PREFIX + "AND_VL" + POSTFIX;
 469     static {
 470         vectorNode(AND_VL, "AndV", TYPE_LONG);
 471     }
 472 
 473     public static final String AND_V_MASK = PREFIX + "AND_V_MASK" + POSTFIX;
 474     static {
 475         beforeMatchingNameRegex(AND_V_MASK, "AndVMask");
 476     }
 477 
 478     public static final String AND_REDUCTION_V = PREFIX + "AND_REDUCTION_V" + POSTFIX;
 479     static {
 480         superWordNodes(AND_REDUCTION_V, "AndReductionV");
 481     }
 482 
 483     public static final String CALL = PREFIX + "CALL" + POSTFIX;
 484     static {
 485         beforeMatchingNameRegex(CALL, "Call.*Java");
 486     }
 487 
 488     public static final String CALL_OF = COMPOSITE_PREFIX + "CALL_OF" + POSTFIX;
 489     static {
 490         callOfNodes(CALL_OF, "Call.*");
 491     }
 492 
 493     public static final String CALL_OF_METHOD = COMPOSITE_PREFIX + "CALL_OF_METHOD" + POSTFIX;
 494     static {
 495         callOfNodes(CALL_OF_METHOD, "Call.*Java");
 496     }
 497 
 498     public static final String STATIC_CALL_OF_METHOD = COMPOSITE_PREFIX + "STATIC_CALL_OF_METHOD" + POSTFIX;
 499     static {
 500         callOfNodes(STATIC_CALL_OF_METHOD, "CallStaticJava");
 501     }
 502 
 503     public static final String CAST_II = PREFIX + "CAST_II" + POSTFIX;
 504     static {
 505         beforeMatchingNameRegex(CAST_II, "CastII");
 506     }
 507 
 508     public static final String CAST_LL = PREFIX + "CAST_LL" + POSTFIX;
 509     static {
 510         beforeMatchingNameRegex(CAST_LL, "CastLL");
 511     }
 512 
 513     public static final String CBNZW_HI = PREFIX + "CBNZW_HI" + POSTFIX;
 514     static {
 515         optoOnly(CBNZW_HI, "cbwhi");
 516     }
 517 
 518     public static final String CBZW_LS = PREFIX + "CBZW_LS" + POSTFIX;
 519     static {
 520         optoOnly(CBZW_LS, "cbwls");
 521     }
 522 
 523     public static final String CBZ_LS = PREFIX + "CBZ_LS" + POSTFIX;
 524     static {
 525         optoOnly(CBZ_LS, "cbls");
 526     }
 527 
 528     public static final String CBZ_HI = PREFIX + "CBZ_HI" + POSTFIX;
 529     static {
 530         optoOnly(CBZ_HI, "cbhi");
 531     }
 532 
 533     public static final String CHECKCAST_ARRAY = PREFIX + "CHECKCAST_ARRAY" + POSTFIX;
 534     static {
 535         String regex = "(((?i:cmp|CLFI|CLR).*precise \\[.*:|.*(?i:mov|mv|or).*precise \\[.*:.*\\R.*(cmp|CMP|CLR))" + END;
 536         optoOnly(CHECKCAST_ARRAY, regex);
 537     }
 538 
 539     public static final String CHECKCAST_ARRAY_OF = COMPOSITE_PREFIX + "CHECKCAST_ARRAY_OF" + POSTFIX;
 540     static {
 541         String regex = "(((?i:cmp|CLFI|CLR).*precise \\[.*" + IS_REPLACED + ":|.*(?i:mov|mv|or).*precise \\[.*" + IS_REPLACED + ":.*\\R.*(cmp|CMP|CLR))" + END;
 542         optoOnly(CHECKCAST_ARRAY_OF, regex);
 543     }
 544 
 545     // Does not work on s390 (a rule containing this regex will be skipped on s390).
 546     public static final String CHECKCAST_ARRAYCOPY = PREFIX + "CHECKCAST_ARRAYCOPY" + POSTFIX;
 547     static {
 548         String regex = "(.*((?i:call_leaf_nofp,runtime)|CALL,\\s?runtime leaf nofp|BCTRL.*.leaf call).*checkcast_arraycopy.*" + END;
 549         optoOnly(CHECKCAST_ARRAYCOPY, regex);
 550     }
 551 
 552     public static final String CLASS_CHECK_TRAP = PREFIX + "CLASS_CHECK_TRAP" + POSTFIX;
 553     static {
 554         trapNodes(CLASS_CHECK_TRAP, "class_check");
 555     }
 556 
 557     public static final String CMOVE_I = PREFIX + "CMOVE_I" + POSTFIX;
 558     static {
 559         beforeMatchingNameRegex(CMOVE_I, "CMoveI");
 560     }
 561 
 562     public static final String CMP_I = PREFIX + "CMP_I" + POSTFIX;
 563     static {
 564         beforeMatchingNameRegex(CMP_I, "CmpI");
 565     }
 566 
 567     public static final String CMP_L = PREFIX + "CMP_L" + POSTFIX;
 568     static {
 569         beforeMatchingNameRegex(CMP_L, "CmpL");
 570     }
 571 
 572     public static final String CMP_U = PREFIX + "CMP_U" + POSTFIX;
 573     static {
 574         beforeMatchingNameRegex(CMP_U, "CmpU\\b");
 575     }
 576 
 577     public static final String CMP_U3 = PREFIX + "CMP_U3" + POSTFIX;
 578     static {
 579         beforeMatchingNameRegex(CMP_U3, "CmpU3");
 580     }
 581 
 582     public static final String CMP_UL = PREFIX + "CMP_UL" + POSTFIX;
 583     static {
 584         beforeMatchingNameRegex(CMP_UL, "CmpUL");
 585     }
 586 
 587     public static final String CMP_UL3 = PREFIX + "CMP_UL3" + POSTFIX;
 588     static {
 589         beforeMatchingNameRegex(CMP_UL3, "CmpUL3");
 590     }
 591 
 592     public static final String CMP_P = PREFIX + "CMP_P" + POSTFIX;
 593     static {
 594         beforeMatchingNameRegex(CMP_P, "CmpP");
 595     }
 596 
 597     public static final String COMPRESS_BITS = PREFIX + "COMPRESS_BITS" + POSTFIX;
 598     static {
 599         beforeMatchingNameRegex(COMPRESS_BITS, "CompressBits");
 600     }
 601 
 602     public static final String CONV = PREFIX + "CONV" + POSTFIX;
 603     static {
 604         beforeMatchingNameRegex(CONV, "Conv");
 605     }
 606 
 607     public static final String CONV_F2HF = PREFIX + "CONV_F2HF" + POSTFIX;
 608     static {
 609         beforeMatchingNameRegex(CONV_F2HF, "ConvF2HF");
 610     }
 611 
 612     public static final String CONV_I2L = PREFIX + "CONV_I2L" + POSTFIX;
 613     static {
 614         beforeMatchingNameRegex(CONV_I2L, "ConvI2L");
 615     }
 616 
 617     public static final String CONV_L2I = PREFIX + "CONV_L2I" + POSTFIX;
 618     static {
 619         beforeMatchingNameRegex(CONV_L2I, "ConvL2I");
 620     }
 621 
 622     public static final String CONV_HF2F = PREFIX + "CONV_HF2F" + POSTFIX;
 623     static {
 624         beforeMatchingNameRegex(CONV_HF2F, "ConvHF2F");
 625     }
 626 
 627     public static final String CON_I = PREFIX + "CON_I" + POSTFIX;
 628     static {
 629         beforeMatchingNameRegex(CON_I, "ConI");
 630     }
 631 
 632     public static final String CON_L = PREFIX + "CON_L" + POSTFIX;
 633     static {
 634         beforeMatchingNameRegex(CON_L, "ConL");
 635     }
 636 
 637     public static final String CON_D = PREFIX + "CON_D" + POSTFIX;
 638     static {
 639         beforeMatchingNameRegex(CON_D, "ConD");
 640     }
 641 
 642     public static final String CON_F = PREFIX + "CON_F" + POSTFIX;
 643     static {
 644         beforeMatchingNameRegex(CON_F, "ConF");
 645     }
 646 
 647     public static final String COUNTED_LOOP = PREFIX + "COUNTED_LOOP" + POSTFIX;
 648     static {
 649         String regex = START + "CountedLoop\\b" + MID + END;
 650         fromAfterCountedLoops(COUNTED_LOOP, regex);
 651     }
 652 
 653     public static final String COUNTED_LOOP_MAIN = PREFIX + "COUNTED_LOOP_MAIN" + POSTFIX;
 654     static {
 655         String regex = START + "CountedLoop\\b" + MID + "main" + END;
 656         fromAfterCountedLoops(COUNTED_LOOP_MAIN, regex);
 657     }
 658 
 659     public static final String DIV = PREFIX + "DIV" + POSTFIX;
 660     static {
 661         beforeMatchingNameRegex(DIV, "Div(I|L|F|D)");
 662     }
 663 
 664     public static final String UDIV = PREFIX + "UDIV" + POSTFIX;
 665     static {
 666         beforeMatchingNameRegex(UDIV, "UDiv(I|L|F|D)");
 667     }
 668 
 669     public static final String DIV_BY_ZERO_TRAP = PREFIX + "DIV_BY_ZERO_TRAP" + POSTFIX;
 670     static {
 671         trapNodes(DIV_BY_ZERO_TRAP, "div0_check");
 672     }
 673 
 674     public static final String DIV_I = PREFIX + "DIV_I" + POSTFIX;
 675     static {
 676         beforeMatchingNameRegex(DIV_I, "DivI");
 677     }
 678 
 679     public static final String DIV_L = PREFIX + "DIV_L" + POSTFIX;
 680     static {
 681         beforeMatchingNameRegex(DIV_L, "DivL");
 682     }
 683 
 684     public static final String DIV_MOD_I = PREFIX + "DIV_MOD_I" + POSTFIX;
 685     static {
 686         beforeMatchingNameRegex(DIV_MOD_I, "DivModI");
 687     }
 688 
 689     public static final String DIV_MOD_L = PREFIX + "DIV_MOD_L" + POSTFIX;
 690     static {
 691         beforeMatchingNameRegex(DIV_MOD_L, "DivModL");
 692     }
 693 
 694     public static final String DIV_VHF = VECTOR_PREFIX + "DIV_VHF" + POSTFIX;
 695     static {
 696         vectorNode(DIV_VHF, "DivVHF", TYPE_SHORT);
 697     }
 698 
 699     public static final String DIV_VF = VECTOR_PREFIX + "DIV_VF" + POSTFIX;
 700     static {
 701         vectorNode(DIV_VF, "DivVF", TYPE_FLOAT);
 702     }
 703 
 704     public static final String DIV_VD = VECTOR_PREFIX + "DIV_VD" + POSTFIX;
 705     static {
 706         vectorNode(DIV_VD, "DivVD", TYPE_DOUBLE);
 707     }
 708 
 709     public static final String DYNAMIC_CALL_OF_METHOD = COMPOSITE_PREFIX + "DYNAMIC_CALL_OF_METHOD" + POSTFIX;
 710     static {
 711         callOfNodes(DYNAMIC_CALL_OF_METHOD, "CallDynamicJava");
 712     }
 713 
 714     public static final String EXPAND_BITS = PREFIX + "EXPAND_BITS" + POSTFIX;
 715     static {
 716         beforeMatchingNameRegex(EXPAND_BITS, "ExpandBits");
 717     }
 718 
 719     public static final String FAST_LOCK = PREFIX + "FAST_LOCK" + POSTFIX;
 720     static {
 721         beforeMatchingNameRegex(FAST_LOCK, "FastLock");
 722     }
 723 
 724     public static final String FAST_UNLOCK = PREFIX + "FAST_UNLOCK" + POSTFIX;
 725     static {
 726         String regex = START + "FastUnlock" + MID + END;
 727         fromMacroToBeforeMatching(FAST_UNLOCK, regex);
 728     }
 729 
 730     public static final String FIELD_ACCESS = PREFIX + "FIELD_ACCESS" + POSTFIX;
 731     static {
 732         String regex = "(.*Field: *" + END;
 733         optoOnly(FIELD_ACCESS, regex);
 734     }
 735 
 736     public static final String FMA_VHF = VECTOR_PREFIX + "FMA_VHF" + POSTFIX;
 737     static {
 738         vectorNode(FMA_VHF, "FmaVHF", TYPE_SHORT);
 739     }
 740 
 741     public static final String FMA_VF = VECTOR_PREFIX + "FMA_VF" + POSTFIX;
 742     static {
 743         vectorNode(FMA_VF, "FmaVF", TYPE_FLOAT);
 744     }
 745 
 746     public static final String FMA_VD = VECTOR_PREFIX + "FMA_VD" + POSTFIX;
 747     static {
 748         vectorNode(FMA_VD, "FmaVD", TYPE_DOUBLE);
 749     }
 750 
 751     public static final String FMA_HF = PREFIX + "FMA_HF" + POSTFIX;
 752     static {
 753         beforeMatchingNameRegex(FMA_HF, "FmaHF");
 754     }
 755 
 756     public static final String G1_COMPARE_AND_EXCHANGE_N_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_COMPARE_AND_EXCHANGE_N_WITH_BARRIER_FLAG" + POSTFIX;
 757     static {
 758         String regex = START + "g1CompareAndExchangeN\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 759         machOnly(G1_COMPARE_AND_EXCHANGE_N_WITH_BARRIER_FLAG, regex);
 760     }
 761 
 762     public static final String G1_COMPARE_AND_EXCHANGE_P_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_COMPARE_AND_EXCHANGE_P_WITH_BARRIER_FLAG" + POSTFIX;
 763     static {
 764         String regex = START + "g1CompareAndExchangeP\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 765         machOnly(G1_COMPARE_AND_EXCHANGE_P_WITH_BARRIER_FLAG, regex);
 766     }
 767 
 768     public static final String G1_COMPARE_AND_SWAP_N_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_COMPARE_AND_SWAP_N_WITH_BARRIER_FLAG" + POSTFIX;
 769     static {
 770         String regex = START + "g1CompareAndSwapN\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 771         machOnly(G1_COMPARE_AND_SWAP_N_WITH_BARRIER_FLAG, regex);
 772     }
 773 
 774     public static final String G1_COMPARE_AND_SWAP_P_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_COMPARE_AND_SWAP_P_WITH_BARRIER_FLAG" + POSTFIX;
 775     static {
 776         String regex = START + "g1CompareAndSwapP\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 777         machOnly(G1_COMPARE_AND_SWAP_P_WITH_BARRIER_FLAG, regex);
 778     }
 779 
 780     public static final String G1_ENCODE_P_AND_STORE_N = PREFIX + "G1_ENCODE_P_AND_STORE_N" + POSTFIX;
 781     static {
 782         machOnlyNameRegex(G1_ENCODE_P_AND_STORE_N, "g1EncodePAndStoreN");
 783     }
 784 
 785     public static final String G1_ENCODE_P_AND_STORE_N_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_ENCODE_P_AND_STORE_N_WITH_BARRIER_FLAG" + POSTFIX;
 786     static {
 787         String regex = START + "g1EncodePAndStoreN\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 788         machOnly(G1_ENCODE_P_AND_STORE_N_WITH_BARRIER_FLAG, regex);
 789     }
 790 
 791     public static final String G1_GET_AND_SET_N_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_GET_AND_SET_N_WITH_BARRIER_FLAG" + POSTFIX;
 792     static {
 793         String regex = START + "g1GetAndSetN\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 794         machOnly(G1_GET_AND_SET_N_WITH_BARRIER_FLAG, regex);
 795     }
 796 
 797     public static final String G1_GET_AND_SET_P_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_GET_AND_SET_P_WITH_BARRIER_FLAG" + POSTFIX;
 798     static {
 799         String regex = START + "g1GetAndSetP\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 800         machOnly(G1_GET_AND_SET_P_WITH_BARRIER_FLAG, regex);
 801     }
 802 
 803     public static final String G1_LOAD_N = PREFIX + "G1_LOAD_N" + POSTFIX;
 804     static {
 805         machOnlyNameRegex(G1_LOAD_N, "g1LoadN");
 806     }
 807 
 808     public static final String G1_LOAD_N_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_LOAD_N_WITH_BARRIER_FLAG" + POSTFIX;
 809     static {
 810         String regex = START + "g1LoadN\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 811         machOnly(G1_LOAD_N_WITH_BARRIER_FLAG, regex);
 812     }
 813 
 814     public static final String G1_LOAD_P_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_LOAD_P_WITH_BARRIER_FLAG" + POSTFIX;
 815     static {
 816         String regex = START + "g1LoadP\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 817         machOnly(G1_LOAD_P_WITH_BARRIER_FLAG, regex);
 818     }
 819 
 820     public static final String G1_STORE_N = PREFIX + "G1_STORE_N" + POSTFIX;
 821     static {
 822         machOnlyNameRegex(G1_STORE_N, "g1StoreN");
 823     }
 824 
 825     public static final String G1_STORE_N_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_STORE_N_WITH_BARRIER_FLAG" + POSTFIX;
 826     static {
 827         String regex = START + "g1StoreN\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 828         machOnly(G1_STORE_N_WITH_BARRIER_FLAG, regex);
 829     }
 830 
 831     public static final String G1_STORE_P = PREFIX + "G1_STORE_P" + POSTFIX;
 832     static {
 833         machOnlyNameRegex(G1_STORE_P, "g1StoreP");
 834     }
 835 
 836     public static final String G1_STORE_P_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "G1_STORE_P_WITH_BARRIER_FLAG" + POSTFIX;
 837     static {
 838         String regex = START + "g1StoreP\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
 839         machOnly(G1_STORE_P_WITH_BARRIER_FLAG, regex);
 840     }
 841 
 842     public static final String IF = PREFIX + "IF" + POSTFIX;
 843     static {
 844         beforeMatchingNameRegex(IF, "If\\b");
 845     }
 846 
 847     public static final String INLINE_TYPE = PREFIX + "INLINE_TYPE" + POSTFIX;
 848     static {
 849         beforeMatchingNameRegex(INLINE_TYPE, "InlineType");
 850     }
 851 
 852     // Does not work for VM builds without JVMCI like x86_32 (a rule containing this regex will be skipped without having JVMCI built).
 853     public static final String INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP = PREFIX + "INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP" + POSTFIX;
 854     static {
 855         trapNodes(INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP, "intrinsic_or_type_checked_inlining");
 856     }
 857 
 858     public static final String INTRINSIC_TRAP = PREFIX + "INTRINSIC_TRAP" + POSTFIX;
 859     static {
 860         trapNodes(INTRINSIC_TRAP, "intrinsic");
 861     }
 862 
 863     // Is only supported on riscv64.
 864     public static final String IS_FINITE_D = PREFIX + "IS_FINITE_D" + POSTFIX;
 865     static {
 866         beforeMatchingNameRegex(IS_FINITE_D, "IsFiniteD");
 867     }
 868 
 869     // Is only supported on riscv64.
 870     public static final String IS_FINITE_F = PREFIX + "IS_FINITE_F" + POSTFIX;
 871     static {
 872         beforeMatchingNameRegex(IS_FINITE_F, "IsFiniteF");
 873     }
 874 
 875     public static final String IS_INFINITE_D = PREFIX + "IS_INFINITE_D" + POSTFIX;
 876     static {
 877         beforeMatchingNameRegex(IS_INFINITE_D, "IsInfiniteD");
 878     }
 879 
 880     public static final String IS_INFINITE_F = PREFIX + "IS_INFINITE_F" + POSTFIX;
 881     static {
 882         beforeMatchingNameRegex(IS_INFINITE_F, "IsInfiniteF");
 883     }
 884 
 885     public static final String LOAD = PREFIX + "LOAD" + POSTFIX;
 886     static {
 887         beforeMatchingNameRegex(LOAD, "Load(B|UB|S|US|I|L|F|D|P|N)");
 888     }
 889 
 890     public static final String LOAD_OF_CLASS = COMPOSITE_PREFIX + "LOAD_OF_CLASS" + POSTFIX;
 891     static {
 892         loadOfNodes(LOAD_OF_CLASS, "Load(B|UB|S|US|I|L|F|D|P|N)");
 893     }
 894 
 895     public static final String LOAD_B = PREFIX + "LOAD_B" + POSTFIX;
 896     static {
 897         beforeMatchingNameRegex(LOAD_B, "LoadB");
 898     }
 899 
 900     public static final String LOAD_B_OF_CLASS = COMPOSITE_PREFIX + "LOAD_B_OF_CLASS" + POSTFIX;
 901     static {
 902         loadOfNodes(LOAD_B_OF_CLASS, "LoadB");
 903     }
 904 
 905     public static final String LOAD_D = PREFIX + "LOAD_D" + POSTFIX;
 906     static {
 907         beforeMatchingNameRegex(LOAD_D, "LoadD");
 908     }
 909 
 910     public static final String LOAD_D_OF_CLASS = COMPOSITE_PREFIX + "LOAD_D_OF_CLASS" + POSTFIX;
 911     static {
 912         loadOfNodes(LOAD_D_OF_CLASS, "LoadD");
 913     }
 914 
 915     public static final String LOAD_F = PREFIX + "LOAD_F" + POSTFIX;
 916     static {
 917         beforeMatchingNameRegex(LOAD_F, "LoadF");
 918     }
 919 
 920     public static final String LOAD_F_OF_CLASS = COMPOSITE_PREFIX + "LOAD_F_OF_CLASS" + POSTFIX;
 921     static {
 922         loadOfNodes(LOAD_F_OF_CLASS, "LoadF");
 923     }
 924 
 925     public static final String LOAD_I = PREFIX + "LOAD_I" + POSTFIX;
 926     static {
 927         beforeMatchingNameRegex(LOAD_I, "LoadI");
 928     }
 929 
 930     public static final String LOAD_I_OF_CLASS = COMPOSITE_PREFIX + "LOAD_I_OF_CLASS" + POSTFIX;
 931     static {
 932         loadOfNodes(LOAD_I_OF_CLASS, "LoadI");
 933     }
 934 
 935     public static final String LOAD_KLASS = PREFIX + "LOAD_KLASS" + POSTFIX;
 936     static {
 937         beforeMatchingNameRegex(LOAD_KLASS, "LoadKlass");
 938     }
 939 
 940     public static final String LOAD_NKLASS = PREFIX + "LOAD_NKLASS" + POSTFIX;
 941     static {
 942         beforeMatchingNameRegex(LOAD_NKLASS, "LoadNKlass");
 943     }
 944 
 945     public static final String LOAD_KLASS_OR_NKLASS = PREFIX + "LOAD_KLASS_OR_NKLASS" + POSTFIX;
 946     static {
 947         beforeMatchingNameRegex(LOAD_KLASS_OR_NKLASS, "LoadN?Klass");
 948     }
 949 
 950     public static final String LOAD_L = PREFIX + "LOAD_L" + POSTFIX;
 951     static {
 952         beforeMatchingNameRegex(LOAD_L, "LoadL");
 953     }
 954 
 955     public static final String LOAD_L_OF_CLASS = COMPOSITE_PREFIX + "LOAD_L_OF_CLASS" + POSTFIX;
 956     static {
 957         loadOfNodes(LOAD_L_OF_CLASS, "LoadL");
 958     }
 959 
 960     public static final String LOAD_N = PREFIX + "LOAD_N" + POSTFIX;
 961     static {
 962         beforeMatchingNameRegex(LOAD_N, "LoadN");
 963     }
 964 
 965     public static final String LOAD_N_OF_CLASS = COMPOSITE_PREFIX + "LOAD_N_OF_CLASS" + POSTFIX;
 966     static {
 967         loadOfNodes(LOAD_N_OF_CLASS, "LoadN");
 968     }
 969 
 970     public static final String LOAD_OF_FIELD = COMPOSITE_PREFIX + "LOAD_OF_FIELD" + POSTFIX;
 971     static {
 972         String regex = START + "Load(B|C|S|I|L|F|D|P|N)" + MID + "@.*name=" + IS_REPLACED + ",.*" + END;
 973         beforeMatching(LOAD_OF_FIELD, regex);
 974     }
 975 
 976     public static final String LOAD_P = PREFIX + "LOAD_P" + POSTFIX;
 977     static {
 978         beforeMatchingNameRegex(LOAD_P, "LoadP");
 979     }
 980 
 981     public static final String LOAD_P_OF_CLASS = COMPOSITE_PREFIX + "LOAD_P_OF_CLASS" + POSTFIX;
 982     static {
 983         loadOfNodes(LOAD_P_OF_CLASS, "LoadP");
 984     }
 985 
 986     public static final String LOAD_S = PREFIX + "LOAD_S" + POSTFIX;
 987     static {
 988         beforeMatchingNameRegex(LOAD_S, "LoadS");
 989     }
 990 
 991     public static final String LOAD_S_OF_CLASS = COMPOSITE_PREFIX + "LOAD_S_OF_CLASS" + POSTFIX;
 992     static {
 993         loadOfNodes(LOAD_S_OF_CLASS, "LoadS");
 994     }
 995 
 996     public static final String LOAD_UB = PREFIX + "LOAD_UB" + POSTFIX;
 997     static {
 998         beforeMatchingNameRegex(LOAD_UB, "LoadUB");
 999     }
1000 
1001     public static final String LOAD_UB_OF_CLASS = COMPOSITE_PREFIX + "LOAD_UB_OF_CLASS" + POSTFIX;
1002     static {
1003         loadOfNodes(LOAD_UB_OF_CLASS, "LoadUB");
1004     }
1005 
1006     public static final String LOAD_US = PREFIX + "LOAD_US" + POSTFIX;
1007     static {
1008         beforeMatchingNameRegex(LOAD_US, "LoadUS");
1009     }
1010 
1011     public static final String LOAD_US_OF_CLASS = COMPOSITE_PREFIX + "LOAD_US_OF_CLASS" + POSTFIX;
1012     static {
1013         loadOfNodes(LOAD_US_OF_CLASS, "LoadUS");
1014     }
1015 
1016     public static final String LOAD_VECTOR_B = VECTOR_PREFIX + "LOAD_VECTOR_B" + POSTFIX;
1017     static {
1018         vectorNode(LOAD_VECTOR_B, "LoadVector", TYPE_BYTE);
1019     }
1020 
1021     public static final String LOAD_VECTOR_C = VECTOR_PREFIX + "LOAD_VECTOR_C" + POSTFIX;
1022     static {
1023         vectorNode(LOAD_VECTOR_C, "LoadVector", TYPE_CHAR);
1024     }
1025 
1026     public static final String LOAD_VECTOR_S = VECTOR_PREFIX + "LOAD_VECTOR_S" + POSTFIX;
1027     static {
1028         vectorNode(LOAD_VECTOR_S, "LoadVector", TYPE_SHORT);
1029     }
1030 
1031     public static final String LOAD_VECTOR_I = VECTOR_PREFIX + "LOAD_VECTOR_I" + POSTFIX;
1032     static {
1033         vectorNode(LOAD_VECTOR_I, "LoadVector", TYPE_INT);
1034     }
1035 
1036     public static final String LOAD_VECTOR_L = VECTOR_PREFIX + "LOAD_VECTOR_L" + POSTFIX;
1037     static {
1038         vectorNode(LOAD_VECTOR_L, "LoadVector", TYPE_LONG);
1039     }
1040 
1041     public static final String LOAD_VECTOR_F = VECTOR_PREFIX + "LOAD_VECTOR_F" + POSTFIX;
1042     static {
1043         vectorNode(LOAD_VECTOR_F, "LoadVector", TYPE_FLOAT);
1044     }
1045 
1046     public static final String LOAD_VECTOR_D = VECTOR_PREFIX + "LOAD_VECTOR_D" + POSTFIX;
1047     static {
1048         vectorNode(LOAD_VECTOR_D, "LoadVector", TYPE_DOUBLE);
1049     }
1050 
1051     public static final String LOAD_VECTOR_GATHER = PREFIX + "LOAD_VECTOR_GATHER" + POSTFIX;
1052     static {
1053         beforeMatchingNameRegex(LOAD_VECTOR_GATHER, "LoadVectorGather");
1054     }
1055 
1056     public static final String LOAD_VECTOR_MASKED = PREFIX + "LOAD_VECTOR_MASKED" + POSTFIX;
1057     static {
1058         beforeMatchingNameRegex(LOAD_VECTOR_MASKED, "LoadVectorMasked");
1059     }
1060 
1061     public static final String LOAD_VECTOR_GATHER_MASKED = PREFIX + "LOAD_VECTOR_GATHER_MASKED" + POSTFIX;
1062     static {
1063         beforeMatchingNameRegex(LOAD_VECTOR_GATHER_MASKED, "LoadVectorGatherMasked");
1064     }
1065 
1066     public static final String LONG_COUNTED_LOOP = PREFIX + "LONG_COUNTED_LOOP" + POSTFIX;
1067     static {
1068         String regex = START + "LongCountedLoop\\b" + MID + END;
1069         fromAfterCountedLoops(LONG_COUNTED_LOOP, regex);
1070     }
1071 
1072     public static final String LOOP = PREFIX + "LOOP" + POSTFIX;
1073     static {
1074         String regex = START + "Loop" + MID + END;
1075         fromBeforeCountedLoops(LOOP, regex);
1076     }
1077 
1078     public static final String LSHIFT = PREFIX + "LSHIFT" + POSTFIX;
1079     static {
1080         beforeMatchingNameRegex(LSHIFT, "LShift(I|L)");
1081     }
1082 
1083     public static final String LSHIFT_I = PREFIX + "LSHIFT_I" + POSTFIX;
1084     static {
1085         beforeMatchingNameRegex(LSHIFT_I, "LShiftI");
1086     }
1087 
1088     public static final String LSHIFT_L = PREFIX + "LSHIFT_L" + POSTFIX;
1089     static {
1090         beforeMatchingNameRegex(LSHIFT_L, "LShiftL");
1091     }
1092 
1093     public static final String LSHIFT_VB = VECTOR_PREFIX + "LSHIFT_VB" + POSTFIX;
1094     static {
1095         vectorNode(LSHIFT_VB, "LShiftVB", TYPE_BYTE);
1096     }
1097 
1098     public static final String LSHIFT_VS = VECTOR_PREFIX + "LSHIFT_VS" + POSTFIX;
1099     static {
1100         vectorNode(LSHIFT_VS, "LShiftVS", TYPE_SHORT);
1101     }
1102 
1103     public static final String LSHIFT_VC = VECTOR_PREFIX + "LSHIFT_VC" + POSTFIX;
1104     static {
1105         vectorNode(LSHIFT_VC, "LShiftVS", TYPE_CHAR); // using short op with char type
1106     }
1107 
1108     public static final String LSHIFT_VI = VECTOR_PREFIX + "LSHIFT_VI" + POSTFIX;
1109     static {
1110         vectorNode(LSHIFT_VI, "LShiftVI", TYPE_INT);
1111     }
1112 
1113     public static final String LSHIFT_VL = VECTOR_PREFIX + "LSHIFT_VL" + POSTFIX;
1114     static {
1115         vectorNode(LSHIFT_VL, "LShiftVL", TYPE_LONG);
1116     }
1117 
1118     public static final String MACH_TEMP = PREFIX + "MACH_TEMP" + POSTFIX;
1119     static {
1120         machOnlyNameRegex(MACH_TEMP, "MachTemp");
1121     }
1122 
1123     public static final String MACRO_LOGIC_V = PREFIX + "MACRO_LOGIC_V" + POSTFIX;
1124     static {
1125         afterBarrierExpansionToBeforeMatching(MACRO_LOGIC_V, "MacroLogicV");
1126     }
1127 
1128     public static final String MAX = PREFIX + "MAX" + POSTFIX;
1129     static {
1130         beforeMatchingNameRegex(MAX, "Max(I|L|F|D)");
1131     }
1132 
1133     public static final String MAX_D = PREFIX + "MAX_D" + POSTFIX;
1134     static {
1135         beforeMatchingNameRegex(MAX_D, "MaxD");
1136     }
1137 
1138     public static final String MAX_D_REDUCTION_REG = PREFIX + "MAX_D_REDUCTION_REG" + POSTFIX;
1139     static {
1140         machOnlyNameRegex(MAX_D_REDUCTION_REG, "maxD_reduction_reg");
1141     }
1142 
1143     public static final String MAX_D_REG = PREFIX + "MAX_D_REG" + POSTFIX;
1144     static {
1145         machOnlyNameRegex(MAX_D_REG, "maxD_reg");
1146     }
1147 
1148     public static final String MAX_F = PREFIX + "MAX_F" + POSTFIX;
1149     static {
1150         beforeMatchingNameRegex(MAX_F, "MaxF");
1151     }
1152 
1153     public static final String MAX_F_REDUCTION_REG = PREFIX + "MAX_F_REDUCTION_REG" + POSTFIX;
1154     static {
1155         machOnlyNameRegex(MAX_F_REDUCTION_REG, "maxF_reduction_reg");
1156     }
1157 
1158     public static final String MAX_F_REG = PREFIX + "MAX_F_REG" + POSTFIX;
1159     static {
1160         machOnlyNameRegex(MAX_F_REG, "maxF_reg");
1161     }
1162 
1163     public static final String MAX_I = PREFIX + "MAX_I" + POSTFIX;
1164     static {
1165         beforeMatchingNameRegex(MAX_I, "MaxI");
1166     }
1167 
1168     public static final String MAX_L = PREFIX + "MAX_L" + POSTFIX;
1169     static {
1170         beforeMatchingNameRegex(MAX_L, "MaxL");
1171     }
1172 
1173     public static final String MAX_VI = VECTOR_PREFIX + "MAX_VI" + POSTFIX;
1174     static {
1175         vectorNode(MAX_VI, "MaxV", TYPE_INT);
1176     }
1177 
1178     public static final String MAX_VHF = VECTOR_PREFIX + "MAX_VHF" + POSTFIX;
1179     static {
1180         vectorNode(MAX_VHF, "MaxVHF", TYPE_SHORT);
1181     }
1182 
1183     public static final String MAX_VF = VECTOR_PREFIX + "MAX_VF" + POSTFIX;
1184     static {
1185         vectorNode(MAX_VF, "MaxV", TYPE_FLOAT);
1186     }
1187 
1188     public static final String MAX_VD = VECTOR_PREFIX + "MAX_VD" + POSTFIX;
1189     static {
1190         vectorNode(MAX_VD, "MaxV", TYPE_DOUBLE);
1191     }
1192 
1193     public static final String MAX_VL = VECTOR_PREFIX + "MAX_VL" + POSTFIX;
1194     static {
1195         vectorNode(MAX_VL, "MaxV", TYPE_LONG);
1196     }
1197 
1198     public static final String MEMBAR = PREFIX + "MEMBAR" + POSTFIX;
1199     static {
1200         beforeMatchingNameRegex(MEMBAR, "MemBar");
1201     }
1202 
1203     public static final String MEMBAR_ACQUIRE = PREFIX + "MEMBAR_ACQUIRE" + POSTFIX;
1204     static {
1205         beforeMatchingNameRegex(MEMBAR_ACQUIRE, "MemBarAcquire");
1206     }
1207 
1208     public static final String MEMBAR_RELEASE = PREFIX + "MEMBAR_RELEASE" + POSTFIX;
1209     static {
1210         beforeMatchingNameRegex(MEMBAR_RELEASE, "MemBarRelease");
1211     }
1212 
1213     public static final String MEMBAR_STORESTORE = PREFIX + "MEMBAR_STORESTORE" + POSTFIX;
1214     static {
1215         beforeMatchingNameRegex(MEMBAR_STORESTORE, "MemBarStoreStore");
1216     }
1217 
1218     public static final String MEMBAR_VOLATILE = PREFIX + "MEMBAR_VOLATILE" + POSTFIX;
1219     static {
1220         beforeMatchingNameRegex(MEMBAR_VOLATILE, "MemBarVolatile");
1221     }
1222 
1223     public static final String MIN = PREFIX + "MIN" + POSTFIX;
1224     static {
1225         beforeMatchingNameRegex(MIN, "Min(I|L)");
1226     }
1227 
1228     public static final String MIN_D = PREFIX + "MIN_D" + POSTFIX;
1229     static {
1230         beforeMatchingNameRegex(MIN_D, "MinD");
1231     }
1232 
1233     public static final String MIN_D_REDUCTION_REG = PREFIX + "MIN_D_REDUCTION_REG" + POSTFIX;
1234     static {
1235         machOnlyNameRegex(MIN_D_REDUCTION_REG, "minD_reduction_reg");
1236     }
1237 
1238     public static final String MIN_D_REG = PREFIX + "MIN_D_REG" + POSTFIX;
1239     static {
1240         machOnlyNameRegex(MIN_D_REG, "minD_reg");
1241     }
1242 
1243     public static final String MIN_F = PREFIX + "MIN_F" + POSTFIX;
1244     static {
1245         beforeMatchingNameRegex(MIN_F, "MinF");
1246     }
1247 
1248     public static final String MIN_F_REDUCTION_REG = PREFIX + "MIN_F_REDUCTION_REG" + POSTFIX;
1249     static {
1250         machOnlyNameRegex(MIN_F_REDUCTION_REG, "minF_reduction_reg");
1251     }
1252 
1253     public static final String MIN_F_REG = PREFIX + "MIN_F_REG" + POSTFIX;
1254     static {
1255         machOnlyNameRegex(MIN_F_REG, "minF_reg");
1256     }
1257 
1258     public static final String MIN_I = PREFIX + "MIN_I" + POSTFIX;
1259     static {
1260         beforeMatchingNameRegex(MIN_I, "MinI");
1261     }
1262 
1263     public static final String MIN_L = PREFIX + "MIN_L" + POSTFIX;
1264     static {
1265         beforeMatchingNameRegex(MIN_L, "MinL");
1266     }
1267 
1268     public static final String MIN_HF = PREFIX + "MIN_HF" + POSTFIX;
1269     static {
1270         beforeMatchingNameRegex(MIN_HF, "MinHF");
1271     }
1272 
1273     public static final String MAX_HF = PREFIX + "MAX_HF" + POSTFIX;
1274     static {
1275         beforeMatchingNameRegex(MAX_HF, "MaxHF");
1276     }
1277 
1278     public static final String MIN_VI = VECTOR_PREFIX + "MIN_VI" + POSTFIX;
1279     static {
1280         vectorNode(MIN_VI, "MinV", TYPE_INT);
1281     }
1282 
1283     public static final String MIN_VHF = VECTOR_PREFIX + "MIN_VHF" + POSTFIX;
1284     static {
1285         vectorNode(MIN_VHF, "MinVHF", TYPE_SHORT);
1286     }
1287 
1288     public static final String MIN_VF = VECTOR_PREFIX + "MIN_VF" + POSTFIX;
1289     static {
1290         vectorNode(MIN_VF, "MinV", TYPE_FLOAT);
1291     }
1292 
1293     public static final String MIN_VD = VECTOR_PREFIX + "MIN_VD" + POSTFIX;
1294     static {
1295         vectorNode(MIN_VD, "MinV", TYPE_DOUBLE);
1296     }
1297 
1298     public static final String MIN_VL = VECTOR_PREFIX + "MIN_VL" + POSTFIX;
1299     static {
1300         vectorNode(MIN_VL, "MinV", TYPE_LONG);
1301     }
1302 
1303     public static final String MOD_I = PREFIX + "MOD_I" + POSTFIX;
1304     static {
1305         beforeMatchingNameRegex(MOD_I, "ModI");
1306     }
1307 
1308     public static final String MOD_L = PREFIX + "MOD_L" + POSTFIX;
1309     static {
1310         beforeMatchingNameRegex(MOD_L, "ModL");
1311     }
1312 
1313     public static final String MOV_F2I = PREFIX + "MOV_F2I" + POSTFIX;
1314     static {
1315         beforeMatchingNameRegex(MOV_F2I, "MoveF2I");
1316     }
1317 
1318     public static final String MOV_I2F = PREFIX + "MOV_I2F" + POSTFIX;
1319     static {
1320         beforeMatchingNameRegex(MOV_I2F, "MoveI2F");
1321     }
1322 
1323     public static final String MOV_D2L = PREFIX + "MOV_D2L" + POSTFIX;
1324     static {
1325         beforeMatchingNameRegex(MOV_D2L, "MoveD2L");
1326     }
1327 
1328     public static final String MOV_L2D = PREFIX + "MOD_L2D" + POSTFIX;
1329     static {
1330         beforeMatchingNameRegex(MOV_L2D, "MoveL2D");
1331     }
1332 
1333     public static final String MUL = PREFIX + "MUL" + POSTFIX;
1334     static {
1335         beforeMatchingNameRegex(MUL, "Mul(I|L|F|D)");
1336     }
1337 
1338     public static final String MUL_ADD_S2I = PREFIX + "MUL_ADD_S2I" + POSTFIX;
1339     static {
1340         beforeMatchingNameRegex(MUL_ADD_S2I, "MulAddS2I");
1341     }
1342 
1343     public static final String MUL_ADD_VS2VI = VECTOR_PREFIX + "MUL_ADD_VS2VI" + POSTFIX;
1344     static {
1345         vectorNode(MUL_ADD_VS2VI, "MulAddVS2VI", TYPE_INT);
1346     }
1347 
1348     // Can only be used if avx512_vnni is available.
1349     public static final String MUL_ADD_VS2VI_VNNI = PREFIX + "MUL_ADD_VS2VI_VNNI" + POSTFIX;
1350     static {
1351         machOnly(MUL_ADD_VS2VI_VNNI, "vmuladdaddS2I_reg");
1352     }
1353 
1354     public static final String MUL_D = PREFIX + "MUL_D" + POSTFIX;
1355     static {
1356         beforeMatchingNameRegex(MUL_D, "MulD");
1357     }
1358 
1359     public static final String MUL_F = PREFIX + "MUL_F" + POSTFIX;
1360     static {
1361         beforeMatchingNameRegex(MUL_F, "MulF");
1362     }
1363 
1364     public static final String MUL_HF = PREFIX + "MUL_HF" + POSTFIX;
1365     static {
1366         beforeMatchingNameRegex(MUL_HF, "MulHF");
1367     }
1368 
1369     public static final String MUL_I = PREFIX + "MUL_I" + POSTFIX;
1370     static {
1371         beforeMatchingNameRegex(MUL_I, "MulI");
1372     }
1373 
1374     public static final String MUL_L = PREFIX + "MUL_L" + POSTFIX;
1375     static {
1376         beforeMatchingNameRegex(MUL_L, "MulL");
1377     }
1378 
1379     public static final String MUL_VL = VECTOR_PREFIX + "MUL_VL" + POSTFIX;
1380     static {
1381         vectorNode(MUL_VL, "MulVL", TYPE_LONG);
1382     }
1383 
1384     public static final String MUL_VI = VECTOR_PREFIX + "MUL_VI" + POSTFIX;
1385     static {
1386         vectorNode(MUL_VI, "MulVI", TYPE_INT);
1387     }
1388 
1389     public static final String MUL_VHF = VECTOR_PREFIX + "MUL_VHF" + POSTFIX;
1390     static {
1391         vectorNode(MUL_VHF, "MulVHF", TYPE_SHORT);
1392     }
1393 
1394     public static final String MUL_VF = VECTOR_PREFIX + "MUL_VF" + POSTFIX;
1395     static {
1396         vectorNode(MUL_VF, "MulVF", TYPE_FLOAT);
1397     }
1398 
1399     public static final String MUL_VD = VECTOR_PREFIX + "MUL_VD" + POSTFIX;
1400     static {
1401         vectorNode(MUL_VD, "MulVD", TYPE_DOUBLE);
1402     }
1403 
1404     public static final String MUL_VB = VECTOR_PREFIX + "MUL_VB" + POSTFIX;
1405     static {
1406         vectorNode(MUL_VB, "MulVB", TYPE_BYTE);
1407     }
1408 
1409     public static final String MUL_VS = VECTOR_PREFIX + "MUL_VS" + POSTFIX;
1410     static {
1411         vectorNode(MUL_VS, "MulVS", TYPE_SHORT);
1412     }
1413 
1414     public static final String MUL_REDUCTION_VD = PREFIX + "MUL_REDUCTION_VD" + POSTFIX;
1415     static {
1416         superWordNodes(MUL_REDUCTION_VD, "MulReductionVD");
1417     }
1418 
1419     public static final String MUL_REDUCTION_VF = PREFIX + "MUL_REDUCTION_VF" + POSTFIX;
1420     static {
1421         superWordNodes(MUL_REDUCTION_VF, "MulReductionVF");
1422     }
1423 
1424     public static final String MUL_REDUCTION_VI = PREFIX + "MUL_REDUCTION_VI" + POSTFIX;
1425     static {
1426         superWordNodes(MUL_REDUCTION_VI, "MulReductionVI");
1427     }
1428 
1429     public static final String MUL_REDUCTION_VL = PREFIX + "MUL_REDUCTION_VL" + POSTFIX;
1430     static {
1431         superWordNodes(MUL_REDUCTION_VL, "MulReductionVL");
1432     }
1433 
1434     public static final String MIN_REDUCTION_V = PREFIX + "MIN_REDUCTION_V" + POSTFIX;
1435     static {
1436         superWordNodes(MIN_REDUCTION_V, "MinReductionV");
1437     }
1438 
1439     public static final String MAX_REDUCTION_V = PREFIX + "MAX_REDUCTION_V" + POSTFIX;
1440     static {
1441         superWordNodes(MAX_REDUCTION_V, "MaxReductionV");
1442     }
1443 
1444     public static final String NEG_F = PREFIX + "NEG_F" + POSTFIX;
1445     static {
1446         beforeMatchingNameRegex(NEG_F, "NegF");
1447     }
1448 
1449     public static final String NEG_D = PREFIX + "NEG_D" + POSTFIX;
1450     static {
1451         beforeMatchingNameRegex(NEG_D, "NegD");
1452     }
1453 
1454     public static final String NEG_VF = VECTOR_PREFIX + "NEG_VF" + POSTFIX;
1455     static {
1456         vectorNode(NEG_VF, "NegVF", TYPE_FLOAT);
1457     }
1458 
1459     public static final String NEG_VD = VECTOR_PREFIX + "NEG_VD" + POSTFIX;
1460     static {
1461         vectorNode(NEG_VD, "NegVD", TYPE_DOUBLE);
1462     }
1463 
1464     public static final String NOP = PREFIX + "NOP" + POSTFIX;
1465     static {
1466         machOnlyNameRegex(NOP, "Nop");
1467     }
1468 
1469     public static final String NULL_ASSERT_TRAP = PREFIX + "NULL_ASSERT_TRAP" + POSTFIX;
1470     static {
1471         trapNodes(NULL_ASSERT_TRAP, "null_assert");
1472     }
1473 
1474     public static final String NULL_CHECK_TRAP = PREFIX + "NULL_CHECK_TRAP" + POSTFIX;
1475     static {
1476         trapNodes(NULL_CHECK_TRAP, "null_check");
1477     }
1478 
1479     public static final String OOPMAP_WITH = COMPOSITE_PREFIX + "OOPMAP_WITH" + POSTFIX;
1480     static {
1481         String regex = "(#\\s*OopMap\\s*\\{.*" + IS_REPLACED + ".*\\})";
1482         optoOnly(OOPMAP_WITH, regex);
1483     }
1484 
1485     public static final String OR_I = PREFIX + "OR_I" + POSTFIX;
1486     static {
1487         beforeMatchingNameRegex(OR_I, "OrI");
1488     }
1489 
1490     public static final String OR_L = PREFIX + "OR_L" + POSTFIX;
1491     static {
1492         beforeMatchingNameRegex(OR_L, "OrL");
1493     }
1494 
1495     public static final String OR_VB = VECTOR_PREFIX + "OR_VB" + POSTFIX;
1496     static {
1497         vectorNode(OR_VB, "OrV", TYPE_BYTE);
1498     }
1499 
1500     public static final String OR_VS = VECTOR_PREFIX + "OR_VS" + POSTFIX;
1501     static {
1502         vectorNode(OR_VS, "OrV", TYPE_SHORT);
1503     }
1504 
1505     public static final String OR_VI = VECTOR_PREFIX + "OR_VI" + POSTFIX;
1506     static {
1507         vectorNode(OR_VI, "OrV", TYPE_INT);
1508     }
1509 
1510     public static final String OR_VL = VECTOR_PREFIX + "OR_VL" + POSTFIX;
1511     static {
1512         vectorNode(OR_VL, "OrV", TYPE_LONG);
1513     }
1514 
1515     public static final String OR_V_MASK = PREFIX + "OR_V_MASK" + POSTFIX;
1516     static {
1517         beforeMatchingNameRegex(OR_V_MASK, "OrVMask");
1518     }
1519 
1520     public static final String OR_REDUCTION_V = PREFIX + "OR_REDUCTION_V" + POSTFIX;
1521     static {
1522         superWordNodes(OR_REDUCTION_V, "OrReductionV");
1523     }
1524 
1525     public static final String OUTER_STRIP_MINED_LOOP = PREFIX + "OUTER_STRIP_MINED_LOOP" + POSTFIX;
1526     static {
1527         String regex = START + "OuterStripMinedLoop\\b" + MID + END;
1528         fromAfterCountedLoops(OUTER_STRIP_MINED_LOOP, regex);
1529     }
1530 
1531     public static final String PARTIAL_SUBTYPE_CHECK = PREFIX + "PARTIAL_SUBTYPE_CHECK" + POSTFIX;
1532     static {
1533         beforeMatchingNameRegex(PARTIAL_SUBTYPE_CHECK, "PartialSubtypeCheck");
1534     }
1535 
1536     public static final String PHI = PREFIX + "PHI" + POSTFIX;
1537     static {
1538         beforeMatchingNameRegex(PHI, "Phi");
1539     }
1540 
1541     public static final String POPCOUNT_L = PREFIX + "POPCOUNT_L" + POSTFIX;
1542     static {
1543         beforeMatchingNameRegex(POPCOUNT_L, "PopCountL");
1544     }
1545 
1546     public static final String POPCOUNT_VI = VECTOR_PREFIX + "POPCOUNT_VI" + POSTFIX;
1547     static {
1548         vectorNode(POPCOUNT_VI, "PopCountVI", TYPE_INT);
1549     }
1550 
1551     public static final String POPCOUNT_VL = VECTOR_PREFIX + "POPCOUNT_VL" + POSTFIX;
1552     static {
1553         vectorNode(POPCOUNT_VL, "PopCountVL", TYPE_LONG);
1554     }
1555 
1556     public static final String COUNT_TRAILING_ZEROS_VL = VECTOR_PREFIX + "COUNT_TRAILING_ZEROS_VL" + POSTFIX;
1557     static {
1558         vectorNode(COUNT_TRAILING_ZEROS_VL, "CountTrailingZerosV", TYPE_LONG);
1559     }
1560 
1561     public static final String COUNT_TRAILING_ZEROS_VI = VECTOR_PREFIX + "COUNT_TRAILING_ZEROS_VI" + POSTFIX;
1562     static {
1563         vectorNode(COUNT_TRAILING_ZEROS_VI, "CountTrailingZerosV", TYPE_INT);
1564     }
1565 
1566     public static final String COUNT_LEADING_ZEROS_VL = VECTOR_PREFIX + "COUNT_LEADING_ZEROS_VL" + POSTFIX;
1567     static {
1568         vectorNode(COUNT_LEADING_ZEROS_VL, "CountLeadingZerosV", TYPE_LONG);
1569     }
1570 
1571     public static final String COUNT_LEADING_ZEROS_VI = VECTOR_PREFIX + "COUNT_LEADING_ZEROS_VI" + POSTFIX;
1572     static {
1573         vectorNode(COUNT_LEADING_ZEROS_VI, "CountLeadingZerosV", TYPE_INT);
1574     }
1575 
1576     public static final String POPULATE_INDEX = PREFIX + "POPULATE_INDEX" + POSTFIX;
1577     static {
1578         String regex = START + "PopulateIndex" + MID + END;
1579         IR_NODE_MAPPINGS.put(POPULATE_INDEX, new SinglePhaseRangeEntry(CompilePhase.PRINT_IDEAL, regex,
1580                                                                        CompilePhase.AFTER_CLOOPS,
1581                                                                        CompilePhase.BEFORE_MATCHING));
1582     }
1583 
1584     public static final String LOOP_PARSE_PREDICATE = PREFIX + "LOOP_PARSE_PREDICATE" + POSTFIX;
1585     static {
1586         parsePredicateNodes(LOOP_PARSE_PREDICATE, "Loop");
1587     }
1588 
1589     public static final String LOOP_LIMIT_CHECK_PARSE_PREDICATE = PREFIX + "LOOP_LIMIT_CHECK_PARSE_PREDICATE" + POSTFIX;
1590     static {
1591         parsePredicateNodes(LOOP_LIMIT_CHECK_PARSE_PREDICATE, "Loop Limit Check");
1592     }
1593 
1594     public static final String PROFILED_LOOP_PARSE_PREDICATE = PREFIX + "PROFILED_LOOP_PARSE_PREDICATE" + POSTFIX;
1595     static {
1596         parsePredicateNodes(PROFILED_LOOP_PARSE_PREDICATE, "Profiled Loop");
1597     }
1598 
1599     public static final String PREDICATE_TRAP = PREFIX + "PREDICATE_TRAP" + POSTFIX;
1600     static {
1601         trapNodes(PREDICATE_TRAP, "predicate");
1602     }
1603 
1604     public static final String RANGE_CHECK_TRAP = PREFIX + "RANGE_CHECK_TRAP" + POSTFIX;
1605     static {
1606         trapNodes(RANGE_CHECK_TRAP, "range_check");
1607     }
1608 
1609     public static final String REINTERPRET_S2HF = PREFIX + "REINTERPRET_S2HF" + POSTFIX;
1610     static {
1611         beforeMatchingNameRegex(REINTERPRET_S2HF, "ReinterpretS2HF");
1612     }
1613 
1614     public static final String REINTERPRET_HF2S = PREFIX + "REINTERPRET_HF2S" + POSTFIX;
1615     static {
1616         beforeMatchingNameRegex(REINTERPRET_HF2S, "ReinterpretHF2S");
1617     }
1618 
1619     public static final String REPLICATE_B = VECTOR_PREFIX + "REPLICATE_B" + POSTFIX;
1620     static {
1621         vectorNode(REPLICATE_B, "Replicate", TYPE_BYTE);
1622     }
1623 
1624     public static final String REPLICATE_S = VECTOR_PREFIX + "REPLICATE_S" + POSTFIX;
1625     static {
1626         vectorNode(REPLICATE_S, "Replicate", TYPE_SHORT);
1627     }
1628 
1629     public static final String REPLICATE_I = VECTOR_PREFIX + "REPLICATE_I" + POSTFIX;
1630     static {
1631         vectorNode(REPLICATE_I, "Replicate", TYPE_INT);
1632     }
1633 
1634     public static final String REPLICATE_L = VECTOR_PREFIX + "REPLICATE_L" + POSTFIX;
1635     static {
1636         vectorNode(REPLICATE_L, "Replicate", TYPE_LONG);
1637     }
1638 
1639     public static final String REPLICATE_F = VECTOR_PREFIX + "REPLICATE_F" + POSTFIX;
1640     static {
1641         vectorNode(REPLICATE_F, "Replicate", TYPE_FLOAT);
1642     }
1643 
1644     public static final String REPLICATE_D = VECTOR_PREFIX + "REPLICATE_D" + POSTFIX;
1645     static {
1646         vectorNode(REPLICATE_D, "Replicate", TYPE_DOUBLE);
1647     }
1648 
1649     public static final String REVERSE_BYTES_I = PREFIX + "REVERSE_BYTES_I" + POSTFIX;
1650     static {
1651         beforeMatchingNameRegex(REVERSE_BYTES_I, "ReverseBytesI");
1652     }
1653 
1654     public static final String REVERSE_BYTES_L = PREFIX + "REVERSE_BYTES_L" + POSTFIX;
1655     static {
1656         beforeMatchingNameRegex(REVERSE_BYTES_L, "ReverseBytesL");
1657     }
1658 
1659     public static final String REVERSE_BYTES_S = PREFIX + "REVERSE_BYTES_S" + POSTFIX;
1660     static {
1661         beforeMatchingNameRegex(REVERSE_BYTES_S, "ReverseBytesS");
1662     }
1663 
1664     public static final String REVERSE_BYTES_US = PREFIX + "REVERSE_BYTES_US" + POSTFIX;
1665     static {
1666         beforeMatchingNameRegex(REVERSE_BYTES_US, "ReverseBytesUS");
1667     }
1668 
1669     public static final String REVERSE_BYTES_VB = VECTOR_PREFIX + "REVERSE_BYTES_VB" + POSTFIX;
1670     static {
1671         vectorNode(REVERSE_BYTES_VB, "ReverseBytesV", TYPE_BYTE);
1672     }
1673 
1674     public static final String REVERSE_BYTES_VS = VECTOR_PREFIX + "REVERSE_BYTES_VS" + POSTFIX;
1675     static {
1676         vectorNode(REVERSE_BYTES_VS, "ReverseBytesV", TYPE_SHORT);
1677     }
1678 
1679     public static final String REVERSE_BYTES_VI = VECTOR_PREFIX + "REVERSE_BYTES_VI" + POSTFIX;
1680     static {
1681         vectorNode(REVERSE_BYTES_VI, "ReverseBytesV", TYPE_INT);
1682     }
1683 
1684     public static final String REVERSE_BYTES_VL = VECTOR_PREFIX + "REVERSE_BYTES_VL" + POSTFIX;
1685     static {
1686         vectorNode(REVERSE_BYTES_VL, "ReverseBytesV", TYPE_LONG);
1687     }
1688 
1689     public static final String REVERSE_I = PREFIX + "REVERSE_I" + POSTFIX;
1690     static {
1691         beforeMatchingNameRegex(REVERSE_I, "ReverseI");
1692     }
1693 
1694     public static final String REVERSE_L = PREFIX + "REVERSE_L" + POSTFIX;
1695     static {
1696         beforeMatchingNameRegex(REVERSE_L, "ReverseL");
1697     }
1698 
1699     public static final String REVERSE_VI = VECTOR_PREFIX + "REVERSE_VI" + POSTFIX;
1700     static {
1701         vectorNode(REVERSE_VI, "ReverseV", TYPE_INT);
1702     }
1703 
1704     public static final String REVERSE_VL = VECTOR_PREFIX + "REVERSE_VL" + POSTFIX;
1705     static {
1706         vectorNode(REVERSE_VL, "ReverseV", TYPE_LONG);
1707     }
1708 
1709     public static final String ROUND_VD = VECTOR_PREFIX + "ROUND_VD" + POSTFIX;
1710     static {
1711         vectorNode(ROUND_VD, "RoundVD", TYPE_LONG);
1712     }
1713 
1714     public static final String ROUND_VF = VECTOR_PREFIX + "ROUND_VF" + POSTFIX;
1715     static {
1716         vectorNode(ROUND_VF, "RoundVF", TYPE_INT);
1717     }
1718 
1719     public static final String ROTATE_LEFT = PREFIX + "ROTATE_LEFT" + POSTFIX;
1720     static {
1721         beforeMatchingNameRegex(ROTATE_LEFT, "RotateLeft");
1722     }
1723 
1724     public static final String ROTATE_RIGHT = PREFIX + "ROTATE_RIGHT" + POSTFIX;
1725     static {
1726         beforeMatchingNameRegex(ROTATE_RIGHT, "RotateRight");
1727     }
1728 
1729     public static final String ROTATE_LEFT_V = PREFIX + "ROTATE_LEFT_V" + POSTFIX;
1730     static {
1731         beforeMatchingNameRegex(ROTATE_LEFT_V, "RotateLeftV");
1732     }
1733 
1734     public static final String ROTATE_RIGHT_V = PREFIX + "ROTATE_RIGHT_V" + POSTFIX;
1735     static {
1736         beforeMatchingNameRegex(ROTATE_RIGHT_V, "RotateRightV");
1737     }
1738 
1739     public static final String ROUND_DOUBLE_MODE_V = VECTOR_PREFIX + "ROUND_DOUBLE_MODE_V" + POSTFIX;
1740     static {
1741         vectorNode(ROUND_DOUBLE_MODE_V, "RoundDoubleModeV", TYPE_DOUBLE);
1742     }
1743 
1744     public static final String RSHIFT = PREFIX + "RSHIFT" + POSTFIX;
1745     static {
1746         beforeMatchingNameRegex(RSHIFT, "RShift(I|L)");
1747     }
1748 
1749     public static final String RSHIFT_I = PREFIX + "RSHIFT_I" + POSTFIX;
1750     static {
1751         beforeMatchingNameRegex(RSHIFT_I, "RShiftI");
1752     }
1753 
1754     public static final String RSHIFT_L = PREFIX + "RSHIFT_L" + POSTFIX;
1755     static {
1756         beforeMatchingNameRegex(RSHIFT_L, "RShiftL");
1757     }
1758 
1759     public static final String RSHIFT_VB = VECTOR_PREFIX + "RSHIFT_VB" + POSTFIX;
1760     static {
1761         vectorNode(RSHIFT_VB, "RShiftVB", TYPE_BYTE);
1762     }
1763 
1764     public static final String RSHIFT_VS = VECTOR_PREFIX + "RSHIFT_VS" + POSTFIX;
1765     static {
1766         vectorNode(RSHIFT_VS, "RShiftVS", TYPE_SHORT);
1767     }
1768 
1769     public static final String RSHIFT_VC = VECTOR_PREFIX + "RSHIFT_VC" + POSTFIX;
1770     static {
1771         vectorNode(RSHIFT_VC, "RShiftVS", TYPE_CHAR); // short computation with char type
1772     }
1773 
1774     public static final String RSHIFT_VI = VECTOR_PREFIX + "RSHIFT_VI" + POSTFIX;
1775     static {
1776         vectorNode(RSHIFT_VI, "RShiftVI", TYPE_INT);
1777     }
1778 
1779     public static final String RSHIFT_VL = VECTOR_PREFIX + "RSHIFT_VL" + POSTFIX;
1780     static {
1781         vectorNode(RSHIFT_VL, "RShiftVL", TYPE_LONG);
1782     }
1783 
1784     public static final String SAFEPOINT = PREFIX + "SAFEPOINT" + POSTFIX;
1785     static {
1786         beforeMatchingNameRegex(SAFEPOINT, "SafePoint");
1787     }
1788 
1789     public static final String SCOPE_OBJECT = PREFIX + "SCOPE_OBJECT" + POSTFIX;
1790     static {
1791         String regex = "(.*# ScObj.*" + END;
1792         optoOnly(SCOPE_OBJECT, regex);
1793     }
1794 
1795     public static final String SIGNUM_VD = VECTOR_PREFIX + "SIGNUM_VD" + POSTFIX;
1796     static {
1797         vectorNode(SIGNUM_VD, "SignumVD", TYPE_DOUBLE);
1798     }
1799 
1800     public static final String SIGNUM_VF = VECTOR_PREFIX + "SIGNUM_VF" + POSTFIX;
1801     static {
1802         vectorNode(SIGNUM_VF, "SignumVF", TYPE_FLOAT);
1803     }
1804 
1805     public static final String SQRT_VHF = VECTOR_PREFIX + "SQRT_VHF" + POSTFIX;
1806     static {
1807         vectorNode(SQRT_VHF, "SqrtVHF", TYPE_SHORT);
1808     }
1809 
1810     public static final String SQRT_HF = PREFIX + "SQRT_HF" + POSTFIX;
1811     static {
1812        beforeMatchingNameRegex(SQRT_HF, "SqrtHF");
1813     }
1814 
1815     public static final String SQRT_F = PREFIX + "SQRT_F" + POSTFIX;
1816     static {
1817        beforeMatchingNameRegex(SQRT_F, "SqrtF");
1818     }
1819 
1820     public static final String SQRT_VF = VECTOR_PREFIX + "SQRT_VF" + POSTFIX;
1821     static {
1822         vectorNode(SQRT_VF, "SqrtVF", TYPE_FLOAT);
1823     }
1824 
1825     public static final String SQRT_VD = VECTOR_PREFIX + "SQRT_VD" + POSTFIX;
1826     static {
1827         vectorNode(SQRT_VD, "SqrtVD", TYPE_DOUBLE);
1828     }
1829 
1830     public static final String STORE = PREFIX + "STORE" + POSTFIX;
1831     static {
1832         beforeMatchingNameRegex(STORE, "Store(B|C|S|I|L|F|D|P|N)");
1833     }
1834 
1835     public static final String STORE_B = PREFIX + "STORE_B" + POSTFIX;
1836     static {
1837         beforeMatchingNameRegex(STORE_B, "StoreB");
1838     }
1839 
1840     public static final String STORE_B_OF_CLASS = COMPOSITE_PREFIX + "STORE_B_OF_CLASS" + POSTFIX;
1841     static {
1842         storeOfNodes(STORE_B_OF_CLASS, "StoreB");
1843     }
1844 
1845     public static final String STORE_C = PREFIX + "STORE_C" + POSTFIX;
1846     static {
1847         beforeMatchingNameRegex(STORE_C, "StoreC");
1848     }
1849 
1850     public static final String STORE_C_OF_CLASS = COMPOSITE_PREFIX + "STORE_C_OF_CLASS" + POSTFIX;
1851     static {
1852         storeOfNodes(STORE_C_OF_CLASS, "StoreC");
1853     }
1854 
1855     public static final String STORE_D = PREFIX + "STORE_D" + POSTFIX;
1856     static {
1857         beforeMatchingNameRegex(STORE_D, "StoreD");
1858     }
1859 
1860     public static final String STORE_D_OF_CLASS = COMPOSITE_PREFIX + "STORE_D_OF_CLASS" + POSTFIX;
1861     static {
1862         storeOfNodes(STORE_D_OF_CLASS, "StoreD");
1863     }
1864 
1865     public static final String STORE_F = PREFIX + "STORE_F" + POSTFIX;
1866     static {
1867         beforeMatchingNameRegex(STORE_F, "StoreF");
1868     }
1869 
1870     public static final String STORE_F_OF_CLASS = COMPOSITE_PREFIX + "STORE_F_OF_CLASS" + POSTFIX;
1871     static {
1872         storeOfNodes(STORE_F_OF_CLASS, "StoreF");
1873     }
1874 
1875     public static final String STORE_I = PREFIX + "STORE_I" + POSTFIX;
1876     static {
1877         beforeMatchingNameRegex(STORE_I, "StoreI");
1878     }
1879 
1880     public static final String STORE_I_OF_CLASS = COMPOSITE_PREFIX + "STORE_I_OF_CLASS" + POSTFIX;
1881     static {
1882         storeOfNodes(STORE_I_OF_CLASS, "StoreI");
1883     }
1884 
1885     public static final String STORE_L = PREFIX + "STORE_L" + POSTFIX;
1886     static {
1887         beforeMatchingNameRegex(STORE_L, "StoreL");
1888     }
1889 
1890     public static final String STORE_L_OF_CLASS = COMPOSITE_PREFIX + "STORE_L_OF_CLASS" + POSTFIX;
1891     static {
1892         storeOfNodes(STORE_L_OF_CLASS, "StoreL");
1893     }
1894 
1895     public static final String STORE_N = PREFIX + "STORE_N" + POSTFIX;
1896     static {
1897         beforeMatchingNameRegex(STORE_N, "StoreN");
1898     }
1899 
1900     public static final String STORE_N_OF_CLASS = COMPOSITE_PREFIX + "STORE_N_OF_CLASS" + POSTFIX;
1901     static {
1902         storeOfNodes(STORE_N_OF_CLASS, "StoreN");
1903     }
1904 
1905     public static final String STORE_OF_CLASS = COMPOSITE_PREFIX + "STORE_OF_CLASS" + POSTFIX;
1906     static {
1907         storeOfNodes(STORE_OF_CLASS, "Store(B|C|S|I|L|F|D|P|N)");
1908     }
1909 
1910     public static final String STORE_OF_FIELD = COMPOSITE_PREFIX + "STORE_OF_FIELD" + POSTFIX;
1911     static {
1912         String regex = START + "Store(B|C|S|I|L|F|D|P|N)" + MID + "@.*name=" + IS_REPLACED + ",.*" + END;
1913         beforeMatching(STORE_OF_FIELD, regex);
1914     }
1915 
1916     public static final String STORE_P = PREFIX + "STORE_P" + POSTFIX;
1917     static {
1918         beforeMatchingNameRegex(STORE_P, "StoreP");
1919     }
1920 
1921     public static final String STORE_P_OF_CLASS = COMPOSITE_PREFIX + "STORE_P_OF_CLASS" + POSTFIX;
1922     static {
1923         storeOfNodes(STORE_P_OF_CLASS, "StoreP");
1924     }
1925 
1926     public static final String STORE_VECTOR = PREFIX + "STORE_VECTOR" + POSTFIX;
1927     static {
1928         beforeMatchingNameRegex(STORE_VECTOR, "StoreVector");
1929     }
1930 
1931     public static final String STORE_VECTOR_SCATTER = PREFIX + "STORE_VECTOR_SCATTER" + POSTFIX;
1932     static {
1933         beforeMatchingNameRegex(STORE_VECTOR_SCATTER, "StoreVectorScatter");
1934     }
1935 
1936     public static final String STORE_VECTOR_MASKED = PREFIX + "STORE_VECTOR_MASKED" + POSTFIX;
1937     static {
1938         beforeMatchingNameRegex(STORE_VECTOR_MASKED, "StoreVectorMasked");
1939     }
1940 
1941     public static final String STORE_VECTOR_SCATTER_MASKED = PREFIX + "STORE_VECTOR_SCATTER_MASKED" + POSTFIX;
1942     static {
1943         beforeMatchingNameRegex(STORE_VECTOR_SCATTER_MASKED, "StoreVectorScatterMasked");
1944     }
1945 
1946     public static final String SUB = PREFIX + "SUB" + POSTFIX;
1947     static {
1948         beforeMatchingNameRegex(SUB, "Sub(I|L|F|D|HF)");
1949     }
1950 
1951     public static final String SUB_D = PREFIX + "SUB_D" + POSTFIX;
1952     static {
1953         beforeMatchingNameRegex(SUB_D, "SubD");
1954     }
1955 
1956     public static final String SUB_F = PREFIX + "SUB_F" + POSTFIX;
1957     static {
1958         beforeMatchingNameRegex(SUB_F, "SubF");
1959     }
1960 
1961     public static final String SUB_HF = PREFIX + "SUB_HF" + POSTFIX;
1962     static {
1963         beforeMatchingNameRegex(SUB_HF, "SubHF");
1964     }
1965 
1966     public static final String SUB_I = PREFIX + "SUB_I" + POSTFIX;
1967     static {
1968         beforeMatchingNameRegex(SUB_I, "SubI");
1969     }
1970 
1971     public static final String SUB_L = PREFIX + "SUB_L" + POSTFIX;
1972     static {
1973         beforeMatchingNameRegex(SUB_L, "SubL");
1974     }
1975 
1976     public static final String SUB_VB = VECTOR_PREFIX + "SUB_VB" + POSTFIX;
1977     static {
1978         vectorNode(SUB_VB, "SubVB", TYPE_BYTE);
1979     }
1980 
1981     public static final String SUB_VS = VECTOR_PREFIX + "SUB_VS" + POSTFIX;
1982     static {
1983         vectorNode(SUB_VS, "SubVS", TYPE_SHORT);
1984     }
1985 
1986     public static final String SUB_VI = VECTOR_PREFIX + "SUB_VI" + POSTFIX;
1987     static {
1988         vectorNode(SUB_VI, "SubVI", TYPE_INT);
1989     }
1990 
1991     public static final String SUB_VL = VECTOR_PREFIX + "SUB_VL" + POSTFIX;
1992     static {
1993         vectorNode(SUB_VL, "SubVL", TYPE_LONG);
1994     }
1995 
1996     public static final String SUB_VHF = VECTOR_PREFIX + "SUB_VHF" + POSTFIX;
1997     static {
1998         vectorNode(SUB_VHF, "SubVHF", TYPE_SHORT);
1999     }
2000 
2001     public static final String SUB_VF = VECTOR_PREFIX + "SUB_VF" + POSTFIX;
2002     static {
2003         vectorNode(SUB_VF, "SubVF", TYPE_FLOAT);
2004     }
2005 
2006     public static final String SUB_VD = VECTOR_PREFIX + "SUB_VD" + POSTFIX;
2007     static {
2008         vectorNode(SUB_VD, "SubVD", TYPE_DOUBLE);
2009     }
2010 
2011     public static final String SUBTYPE_CHECK = PREFIX + "SUBTYPE_CHECK" + POSTFIX;
2012     static {
2013         String regex = START + "SubTypeCheck" + MID + END;
2014         macroNodes(SUBTYPE_CHECK, regex);
2015     }
2016 
2017     public static final String TRAP = PREFIX + "TRAP" + POSTFIX;
2018     static {
2019         trapNodes(TRAP, "reason");
2020     }
2021 
2022     public static final String DIV_HF = PREFIX + "DIV_HF" + POSTFIX;
2023     static {
2024         beforeMatchingNameRegex(DIV_HF, "DivHF");
2025     }
2026 
2027     public static final String UDIV_I = PREFIX + "UDIV_I" + POSTFIX;
2028     static {
2029         beforeMatchingNameRegex(UDIV_I, "UDivI");
2030     }
2031 
2032     public static final String UDIV_L = PREFIX + "UDIV_L" + POSTFIX;
2033     static {
2034         beforeMatchingNameRegex(UDIV_L, "UDivL");
2035     }
2036 
2037     public static final String UDIV_MOD_I = PREFIX + "UDIV_MOD_I" + POSTFIX;
2038     static {
2039         beforeMatchingNameRegex(UDIV_MOD_I, "UDivModI");
2040     }
2041 
2042     public static final String UDIV_MOD_L = PREFIX + "UDIV_MOD_L" + POSTFIX;
2043     static {
2044         beforeMatchingNameRegex(UDIV_MOD_L, "UDivModL");
2045     }
2046 
2047     public static final String UMOD_I = PREFIX + "UMOD_I" + POSTFIX;
2048     static {
2049         beforeMatchingNameRegex(UMOD_I, "UModI");
2050     }
2051 
2052     public static final String UMOD_L = PREFIX + "UMOD_L" + POSTFIX;
2053     static {
2054         beforeMatchingNameRegex(UMOD_L, "UModL");
2055     }
2056 
2057     public static final String UNHANDLED_TRAP = PREFIX + "UNHANDLED_TRAP" + POSTFIX;
2058     static {
2059         trapNodes(UNHANDLED_TRAP, "unhandled");
2060     }
2061 
2062     public static final String UNSTABLE_IF_TRAP = PREFIX + "UNSTABLE_IF_TRAP" + POSTFIX;
2063     static {
2064         trapNodes(UNSTABLE_IF_TRAP, "unstable_if");
2065     }
2066 
2067     public static final String UNREACHED_TRAP = PREFIX + "UNREACHED_TRAP" + POSTFIX;
2068     static {
2069         trapNodes(UNREACHED_TRAP, "unreached");
2070     }
2071 
2072     public static final String URSHIFT = PREFIX + "URSHIFT" + POSTFIX;
2073     static {
2074         beforeMatchingNameRegex(URSHIFT, "URShift(B|S|I|L)");
2075     }
2076 
2077     public static final String URSHIFT_B = PREFIX + "URSHIFT_B" + POSTFIX;
2078     static {
2079         beforeMatchingNameRegex(URSHIFT_B, "URShiftB");
2080     }
2081 
2082     public static final String URSHIFT_I = PREFIX + "URSHIFT_I" + POSTFIX;
2083     static {
2084         beforeMatchingNameRegex(URSHIFT_I, "URShiftI");
2085     }
2086 
2087     public static final String URSHIFT_L = PREFIX + "URSHIFT_L" + POSTFIX;
2088     static {
2089         beforeMatchingNameRegex(URSHIFT_L, "URShiftL");
2090     }
2091 
2092     public static final String URSHIFT_S = PREFIX + "URSHIFT_S" + POSTFIX;
2093     static {
2094         beforeMatchingNameRegex(URSHIFT_S, "URShiftS");
2095     }
2096 
2097     public static final String URSHIFT_VB = VECTOR_PREFIX + "URSHIFT_VB" + POSTFIX;
2098     static {
2099         vectorNode(URSHIFT_VB, "URShiftVB", TYPE_BYTE);
2100     }
2101 
2102     public static final String URSHIFT_VS = VECTOR_PREFIX + "URSHIFT_VS" + POSTFIX;
2103     static {
2104         vectorNode(URSHIFT_VS, "URShiftVS", TYPE_SHORT);
2105     }
2106 
2107     public static final String URSHIFT_VC = VECTOR_PREFIX + "URSHIFT_VC" + POSTFIX;
2108     static {
2109         vectorNode(URSHIFT_VC, "URShiftVS", TYPE_CHAR); // short computation with char type
2110     }
2111 
2112     public static final String URSHIFT_VI = VECTOR_PREFIX + "URSHIFT_VI" + POSTFIX;
2113     static {
2114         vectorNode(URSHIFT_VI, "URShiftVI", TYPE_INT);
2115     }
2116 
2117     public static final String URSHIFT_VL = VECTOR_PREFIX + "URSHIFT_VL" + POSTFIX;
2118     static {
2119         vectorNode(URSHIFT_VL, "URShiftVL", TYPE_LONG);
2120     }
2121 
2122     public static final String VAND_NOT_I = PREFIX + "VAND_NOT_I" + POSTFIX;
2123     static {
2124         machOnlyNameRegex(VAND_NOT_I, "vand_notI");
2125     }
2126 
2127     public static final String VAND_NOT_L = PREFIX + "VAND_NOT_L" + POSTFIX;
2128     static {
2129         machOnlyNameRegex(VAND_NOT_L, "vand_notL");
2130     }
2131 
2132     public static final String VAND_NOT_I_MASKED = PREFIX + "VAND_NOT_I_MASKED" + POSTFIX;
2133     static {
2134         machOnlyNameRegex(VAND_NOT_I_MASKED, "vand_notI_masked");
2135     }
2136 
2137     public static final String VAND_NOT_L_MASKED = PREFIX + "VAND_NOT_L_MASKED" + POSTFIX;
2138     static {
2139         machOnlyNameRegex(VAND_NOT_L_MASKED, "vand_notL_masked");
2140     }
2141 
2142     public static final String VECTOR_BLEND_B = VECTOR_PREFIX + "VECTOR_BLEND_B" + POSTFIX;
2143     static {
2144         vectorNode(VECTOR_BLEND_B, "VectorBlend", TYPE_BYTE);
2145     }
2146 
2147     public static final String VECTOR_BLEND_S = VECTOR_PREFIX + "VECTOR_BLEND_S" + POSTFIX;
2148     static {
2149         vectorNode(VECTOR_BLEND_S, "VectorBlend", TYPE_SHORT);
2150     }
2151 
2152     public static final String VECTOR_BLEND_I = VECTOR_PREFIX + "VECTOR_BLEND_I" + POSTFIX;
2153     static {
2154         vectorNode(VECTOR_BLEND_I, "VectorBlend", TYPE_INT);
2155     }
2156 
2157     public static final String VECTOR_BLEND_L = VECTOR_PREFIX + "VECTOR_BLEND_L" + POSTFIX;
2158     static {
2159         vectorNode(VECTOR_BLEND_L, "VectorBlend", TYPE_LONG);
2160     }
2161 
2162     public static final String VECTOR_BLEND_F = VECTOR_PREFIX + "VECTOR_BLEND_F" + POSTFIX;
2163     static {
2164         vectorNode(VECTOR_BLEND_F, "VectorBlend", TYPE_FLOAT);
2165     }
2166 
2167     public static final String VECTOR_BLEND_D = VECTOR_PREFIX + "VECTOR_BLEND_D" + POSTFIX;
2168     static {
2169         vectorNode(VECTOR_BLEND_D, "VectorBlend", TYPE_DOUBLE);
2170     }
2171 
2172     public static final String VECTOR_MASK_CMP_I = VECTOR_PREFIX + "VECTOR_MASK_CMP_I" + POSTFIX;
2173     static {
2174         vectorNode(VECTOR_MASK_CMP_I, "VectorMaskCmp", TYPE_INT);
2175     }
2176 
2177     public static final String VECTOR_MASK_CMP_L = VECTOR_PREFIX + "VECTOR_MASK_CMP_L" + POSTFIX;
2178     static {
2179         vectorNode(VECTOR_MASK_CMP_L, "VectorMaskCmp", TYPE_LONG);
2180     }
2181 
2182     public static final String VECTOR_MASK_CMP_F = VECTOR_PREFIX + "VECTOR_MASK_CMP_F" + POSTFIX;
2183     static {
2184         vectorNode(VECTOR_MASK_CMP_F, "VectorMaskCmp", TYPE_FLOAT);
2185     }
2186 
2187     public static final String VECTOR_MASK_CMP_D = VECTOR_PREFIX + "VECTOR_MASK_CMP_D" + POSTFIX;
2188     static {
2189         vectorNode(VECTOR_MASK_CMP_D, "VectorMaskCmp", TYPE_DOUBLE);
2190     }
2191 
2192     public static final String VECTOR_CAST_B2S = VECTOR_PREFIX + "VECTOR_CAST_B2S" + POSTFIX;
2193     static {
2194         vectorNode(VECTOR_CAST_B2S, "VectorCastB2X", TYPE_SHORT);
2195     }
2196 
2197     public static final String VECTOR_CAST_B2I = VECTOR_PREFIX + "VECTOR_CAST_B2I" + POSTFIX;
2198     static {
2199         vectorNode(VECTOR_CAST_B2I, "VectorCastB2X", TYPE_INT);
2200     }
2201 
2202     public static final String VECTOR_CAST_B2L = VECTOR_PREFIX + "VECTOR_CAST_B2L" + POSTFIX;
2203     static {
2204         vectorNode(VECTOR_CAST_B2L, "VectorCastB2X", TYPE_LONG);
2205     }
2206 
2207     public static final String VECTOR_CAST_B2F = VECTOR_PREFIX + "VECTOR_CAST_B2F" + POSTFIX;
2208     static {
2209         vectorNode(VECTOR_CAST_B2F, "VectorCastB2X", TYPE_FLOAT);
2210     }
2211 
2212     public static final String VECTOR_CAST_B2D = VECTOR_PREFIX + "VECTOR_CAST_B2D" + POSTFIX;
2213     static {
2214         vectorNode(VECTOR_CAST_B2D, "VectorCastB2X", TYPE_DOUBLE);
2215     }
2216 
2217     public static final String VECTOR_CAST_D2B = VECTOR_PREFIX + "VECTOR_CAST_D2B" + POSTFIX;
2218     static {
2219         vectorNode(VECTOR_CAST_D2B, "VectorCastD2X", TYPE_BYTE);
2220     }
2221 
2222     public static final String VECTOR_CAST_D2S = VECTOR_PREFIX + "VECTOR_CAST_D2S" + POSTFIX;
2223     static {
2224         vectorNode(VECTOR_CAST_D2S, "VectorCastD2X", TYPE_SHORT);
2225     }
2226 
2227     public static final String VECTOR_CAST_D2I = VECTOR_PREFIX + "VECTOR_CAST_D2I" + POSTFIX;
2228     static {
2229         vectorNode(VECTOR_CAST_D2I, "VectorCastD2X", TYPE_INT);
2230     }
2231 
2232     public static final String VECTOR_CAST_D2L = VECTOR_PREFIX + "VECTOR_CAST_D2L" + POSTFIX;
2233     static {
2234         vectorNode(VECTOR_CAST_D2L, "VectorCastD2X", TYPE_LONG);
2235     }
2236 
2237     public static final String VECTOR_CAST_D2F = VECTOR_PREFIX + "VECTOR_CAST_D2F" + POSTFIX;
2238     static {
2239         vectorNode(VECTOR_CAST_D2F, "VectorCastD2X", TYPE_FLOAT);
2240     }
2241 
2242     public static final String VECTOR_CAST_F2B = VECTOR_PREFIX + "VECTOR_CAST_F2B" + POSTFIX;
2243     static {
2244         vectorNode(VECTOR_CAST_F2B, "VectorCastF2X", TYPE_BYTE);
2245     }
2246 
2247     public static final String VECTOR_CAST_F2S = VECTOR_PREFIX + "VECTOR_CAST_F2S" + POSTFIX;
2248     static {
2249         vectorNode(VECTOR_CAST_F2S, "VectorCastF2X", TYPE_SHORT);
2250     }
2251 
2252     public static final String VECTOR_CAST_F2I = VECTOR_PREFIX + "VECTOR_CAST_F2I" + POSTFIX;
2253     static {
2254         vectorNode(VECTOR_CAST_F2I, "VectorCastF2X", TYPE_INT);
2255     }
2256 
2257     public static final String VECTOR_CAST_F2L = VECTOR_PREFIX + "VECTOR_CAST_F2L" + POSTFIX;
2258     static {
2259         vectorNode(VECTOR_CAST_F2L, "VectorCastF2X", TYPE_LONG);
2260     }
2261 
2262     public static final String VECTOR_CAST_F2D = VECTOR_PREFIX + "VECTOR_CAST_F2D" + POSTFIX;
2263     static {
2264         vectorNode(VECTOR_CAST_F2D, "VectorCastF2X", TYPE_DOUBLE);
2265     }
2266 
2267     public static final String VECTOR_CAST_I2B = VECTOR_PREFIX + "VECTOR_CAST_I2B" + POSTFIX;
2268     static {
2269         vectorNode(VECTOR_CAST_I2B, "VectorCastI2X", TYPE_BYTE);
2270     }
2271 
2272     public static final String VECTOR_CAST_I2S = VECTOR_PREFIX + "VECTOR_CAST_I2S" + POSTFIX;
2273     static {
2274         vectorNode(VECTOR_CAST_I2S, "VectorCastI2X", TYPE_SHORT);
2275     }
2276 
2277     public static final String VECTOR_CAST_I2L = VECTOR_PREFIX + "VECTOR_CAST_I2L" + POSTFIX;
2278     static {
2279         vectorNode(VECTOR_CAST_I2L, "VectorCastI2X", TYPE_LONG);
2280     }
2281 
2282     public static final String VECTOR_CAST_I2F = VECTOR_PREFIX + "VECTOR_CAST_I2F" + POSTFIX;
2283     static {
2284         vectorNode(VECTOR_CAST_I2F, "VectorCastI2X", TYPE_FLOAT);
2285     }
2286 
2287     public static final String VECTOR_CAST_I2D = VECTOR_PREFIX + "VECTOR_CAST_I2D" + POSTFIX;
2288     static {
2289         vectorNode(VECTOR_CAST_I2D, "VectorCastI2X", TYPE_DOUBLE);
2290     }
2291 
2292     public static final String VECTOR_CAST_L2B = VECTOR_PREFIX + "VECTOR_CAST_L2B" + POSTFIX;
2293     static {
2294         vectorNode(VECTOR_CAST_L2B, "VectorCastL2X", TYPE_BYTE);
2295     }
2296 
2297     public static final String VECTOR_CAST_L2S = VECTOR_PREFIX + "VECTOR_CAST_L2S" + POSTFIX;
2298     static {
2299         vectorNode(VECTOR_CAST_L2S, "VectorCastL2X", TYPE_SHORT);
2300     }
2301 
2302     public static final String VECTOR_CAST_L2I = VECTOR_PREFIX + "VECTOR_CAST_L2I" + POSTFIX;
2303     static {
2304         vectorNode(VECTOR_CAST_L2I, "VectorCastL2X", TYPE_INT);
2305     }
2306 
2307     public static final String VECTOR_CAST_L2F = VECTOR_PREFIX + "VECTOR_CAST_L2F" + POSTFIX;
2308     static {
2309         vectorNode(VECTOR_CAST_L2F, "VectorCastL2X", TYPE_FLOAT);
2310     }
2311 
2312     public static final String VECTOR_CAST_L2D = VECTOR_PREFIX + "VECTOR_CAST_L2D" + POSTFIX;
2313     static {
2314         vectorNode(VECTOR_CAST_L2D, "VectorCastL2X", TYPE_DOUBLE);
2315     }
2316 
2317     public static final String VECTOR_CAST_S2B = VECTOR_PREFIX + "VECTOR_CAST_S2B" + POSTFIX;
2318     static {
2319         vectorNode(VECTOR_CAST_S2B, "VectorCastS2X", TYPE_BYTE);
2320     }
2321 
2322     public static final String VECTOR_CAST_S2I = VECTOR_PREFIX + "VECTOR_CAST_S2I" + POSTFIX;
2323     static {
2324         vectorNode(VECTOR_CAST_S2I, "VectorCastS2X", TYPE_INT);
2325     }
2326 
2327     public static final String VECTOR_CAST_S2L = VECTOR_PREFIX + "VECTOR_CAST_S2L" + POSTFIX;
2328     static {
2329         vectorNode(VECTOR_CAST_S2L, "VectorCastS2X", TYPE_LONG);
2330     }
2331 
2332     public static final String VECTOR_CAST_S2F = VECTOR_PREFIX + "VECTOR_CAST_S2F" + POSTFIX;
2333     static {
2334         vectorNode(VECTOR_CAST_S2F, "VectorCastS2X", TYPE_FLOAT);
2335     }
2336 
2337     public static final String VECTOR_CAST_S2D = VECTOR_PREFIX + "VECTOR_CAST_S2D" + POSTFIX;
2338     static {
2339         vectorNode(VECTOR_CAST_S2D, "VectorCastS2X", TYPE_DOUBLE);
2340     }
2341 
2342     public static final String VECTOR_CAST_F2HF = VECTOR_PREFIX + "VECTOR_CAST_F2HF" + POSTFIX;
2343     static {
2344         vectorNode(VECTOR_CAST_F2HF, "VectorCastF2HF", TYPE_SHORT);
2345     }
2346 
2347     public static final String VECTOR_CAST_HF2F = VECTOR_PREFIX + "VECTOR_CAST_HF2F" + POSTFIX;
2348     static {
2349         vectorNode(VECTOR_CAST_HF2F, "VectorCastHF2F", TYPE_FLOAT);
2350     }
2351 
2352     public static final String VECTOR_MASK_CAST = PREFIX + "VECTOR_MASK_CAST" + POSTFIX;
2353     static {
2354         beforeMatchingNameRegex(VECTOR_MASK_CAST, "VectorMaskCast");
2355     }
2356 
2357     public static final String VECTOR_REINTERPRET = PREFIX + "VECTOR_REINTERPRET" + POSTFIX;
2358     static {
2359         beforeMatchingNameRegex(VECTOR_REINTERPRET, "VectorReinterpret");
2360     }
2361 
2362     public static final String VECTOR_UCAST_B2S = VECTOR_PREFIX + "VECTOR_UCAST_B2S" + POSTFIX;
2363     static {
2364         vectorNode(VECTOR_UCAST_B2S, "VectorUCastB2X", TYPE_SHORT);
2365     }
2366 
2367     public static final String VECTOR_UCAST_B2I = VECTOR_PREFIX + "VECTOR_UCAST_B2I" + POSTFIX;
2368     static {
2369         vectorNode(VECTOR_UCAST_B2I, "VectorUCastB2X", TYPE_INT);
2370     }
2371 
2372     public static final String VECTOR_UCAST_B2L = VECTOR_PREFIX + "VECTOR_UCAST_B2L" + POSTFIX;
2373     static {
2374         vectorNode(VECTOR_UCAST_B2L, "VectorUCastB2X", TYPE_LONG);
2375     }
2376 
2377     public static final String VECTOR_UCAST_I2L = VECTOR_PREFIX + "VECTOR_UCAST_I2L" + POSTFIX;
2378     static {
2379         vectorNode(VECTOR_UCAST_I2L, "VectorUCastI2X", TYPE_LONG);
2380     }
2381 
2382     public static final String VECTOR_UCAST_S2I = VECTOR_PREFIX + "VECTOR_UCAST_S2I" + POSTFIX;
2383     static {
2384         vectorNode(VECTOR_UCAST_S2I, "VectorUCastS2X", TYPE_INT);
2385     }
2386 
2387     public static final String VECTOR_UCAST_S2L = VECTOR_PREFIX + "VECTOR_UCAST_S2L" + POSTFIX;
2388     static {
2389         vectorNode(VECTOR_UCAST_S2L, "VectorUCastS2X", TYPE_LONG);
2390     }
2391 
2392     public static final String VECTOR_TEST = PREFIX + "VECTOR_TEST" + POSTFIX;
2393     static {
2394         beforeMatchingNameRegex(VECTOR_TEST, "VectorTest");
2395     }
2396 
2397     public static final String VFABD = PREFIX + "VFABD" + POSTFIX;
2398     static {
2399         machOnlyNameRegex(VFABD, "vfabd");
2400     }
2401 
2402     public static final String VFABD_MASKED = PREFIX + "VFABD_MASKED" + POSTFIX;
2403     static {
2404         machOnlyNameRegex(VFABD_MASKED, "vfabd_masked");
2405     }
2406 
2407     public static final String VFMSB_MASKED = PREFIX + "VFMSB_MASKED" + POSTFIX;
2408     static {
2409         machOnlyNameRegex(VFMSB_MASKED, "vfmsb_masked");
2410     }
2411 
2412     public static final String VFNMAD_MASKED = PREFIX + "VFNMAD_MASKED" + POSTFIX;
2413     static {
2414         machOnlyNameRegex(VFNMAD_MASKED, "vfnmad_masked");
2415     }
2416 
2417     public static final String VFNMSB_MASKED = PREFIX + "VFNMSB_MASKED" + POSTFIX;
2418     static {
2419         machOnlyNameRegex(VFNMSB_MASKED, "vfnmsb_masked");
2420     }
2421 
2422     public static final String VFMAD_MASKED = PREFIX + "VFMAD_MASKED" + POSTFIX;
2423     static {
2424         machOnlyNameRegex(VFMAD_MASKED, "vfmad_masked");
2425     }
2426 
2427     public static final String VMASK_AND_NOT_L = PREFIX + "VMASK_AND_NOT_L" + POSTFIX;
2428     static {
2429         machOnlyNameRegex(VMASK_AND_NOT_L, "vmask_and_notL");
2430     }
2431 
2432     public static final String VMLA = PREFIX + "VMLA" + POSTFIX;
2433     static {
2434         machOnlyNameRegex(VMLA, "vmla");
2435     }
2436 
2437     public static final String VMLA_MASKED = PREFIX + "VMLA_MASKED" + POSTFIX;
2438     static {
2439         machOnlyNameRegex(VMLA_MASKED, "vmla_masked");
2440     }
2441 
2442     public static final String FMSUB = PREFIX + "FMSUB" + POSTFIX;
2443     static {
2444         machOnlyNameRegex(FMSUB, "msub(F|D)_reg_reg");
2445     }
2446 
2447     public static final String FNMADD = PREFIX + "FNMADD" + POSTFIX;
2448     static {
2449         machOnlyNameRegex(FNMADD, "mnadd(F|D)_reg_reg");
2450     }
2451 
2452     public static final String FNMSUB = PREFIX + "FNMSUB" + POSTFIX;
2453     static {
2454         machOnlyNameRegex(FNMSUB, "mnsub(F|D)_reg_reg");
2455     }
2456 
2457     public static final String VFMLA = PREFIX + "VFMLA" + POSTFIX;
2458     static {
2459         machOnlyNameRegex(VFMLA, "vfmla");
2460     }
2461 
2462     public static final String VFMLS = PREFIX + "VFMLS" + POSTFIX;
2463     static {
2464         machOnlyNameRegex(VFMLS, "vfmls");
2465     }
2466 
2467     public static final String VFNMLA = PREFIX + "VFNMLA" + POSTFIX;
2468     static {
2469         machOnlyNameRegex(VFNMLA, "vfnmla");
2470     }
2471 
2472     public static final String VMLS = PREFIX + "VMLS" + POSTFIX;
2473     static {
2474         machOnlyNameRegex(VMLS, "vmls");
2475     }
2476 
2477     public static final String VMLS_MASKED = PREFIX + "VMLS_MASKED" + POSTFIX;
2478     static {
2479         machOnlyNameRegex(VMLS_MASKED, "vmls_masked");
2480     }
2481 
2482     public static final String VMASK_CMP_ZERO_I_NEON = PREFIX + "VMASK_CMP_ZERO_I_NEON" + POSTFIX;
2483     static {
2484         machOnlyNameRegex(VMASK_CMP_ZERO_I_NEON, "vmaskcmp_zeroI_neon");
2485     }
2486 
2487     public static final String VMASK_CMP_ZERO_L_NEON = PREFIX + "VMASK_CMP_ZERO_L_NEON" + POSTFIX;
2488     static {
2489         machOnlyNameRegex(VMASK_CMP_ZERO_L_NEON, "vmaskcmp_zeroL_neon");
2490     }
2491 
2492     public static final String VMASK_CMP_ZERO_F_NEON = PREFIX + "VMASK_CMP_ZERO_F_NEON" + POSTFIX;
2493     static {
2494         machOnlyNameRegex(VMASK_CMP_ZERO_F_NEON, "vmaskcmp_zeroF_neon");
2495     }
2496 
2497     public static final String VMASK_CMP_ZERO_D_NEON = PREFIX + "VMASK_CMP_ZERO_D_NEON" + POSTFIX;
2498     static {
2499         machOnlyNameRegex(VMASK_CMP_ZERO_D_NEON, "vmaskcmp_zeroD_neon");
2500     }
2501 
2502     public static final String VMASK_CMP_IMM_I_SVE = PREFIX + "VMASK_CMP_IMM_I_SVE" + POSTFIX;
2503     static {
2504         machOnlyNameRegex(VMASK_CMP_IMM_I_SVE, "vmaskcmp_immI_sve");
2505     }
2506 
2507     public static final String VMASK_CMPU_IMM_I_SVE = PREFIX + "VMASK_CMPU_IMM_I_SVE" + POSTFIX;
2508     static {
2509         machOnlyNameRegex(VMASK_CMPU_IMM_I_SVE, "vmaskcmpU_immI_sve");
2510     }
2511 
2512     public static final String VMASK_CMP_IMM_L_SVE = PREFIX + "VMASK_CMP_IMM_L_SVE" + POSTFIX;
2513     static {
2514         machOnlyNameRegex(VMASK_CMP_IMM_L_SVE, "vmaskcmp_immL_sve");
2515     }
2516 
2517     public static final String VMASK_CMPU_IMM_L_SVE = PREFIX + "VMASK_CMPU_IMM_L_SVE" + POSTFIX;
2518     static {
2519         machOnlyNameRegex(VMASK_CMPU_IMM_L_SVE, "vmaskcmpU_immL_sve");
2520     }
2521 
2522     public static final String VNOT_I_MASKED = PREFIX + "VNOT_I_MASKED" + POSTFIX;
2523     static {
2524         machOnlyNameRegex(VNOT_I_MASKED, "vnotI_masked");
2525     }
2526 
2527     public static final String VNOT_L_MASKED = PREFIX + "VNOT_L_MASKED" + POSTFIX;
2528     static {
2529         machOnlyNameRegex(VNOT_L_MASKED, "vnotL_masked");
2530     }
2531 
2532     public static final String VSTOREMASK_TRUECOUNT = PREFIX + "VSTOREMASK_TRUECOUNT" + POSTFIX;
2533     static {
2534         machOnlyNameRegex(VSTOREMASK_TRUECOUNT, "vstoremask_truecount_neon");
2535     }
2536 
2537     public static final String XOR = PREFIX + "XOR" + POSTFIX;
2538     static {
2539         beforeMatchingNameRegex(XOR, "Xor(I|L)");
2540     }
2541 
2542     public static final String XOR_I = PREFIX + "XOR_I" + POSTFIX;
2543     static {
2544         beforeMatchingNameRegex(XOR_I, "XorI");
2545     }
2546 
2547     public static final String XOR_L = PREFIX + "XOR_L" + POSTFIX;
2548     static {
2549         beforeMatchingNameRegex(XOR_L, "XorL");
2550     }
2551 
2552     public static final String XOR_VB = VECTOR_PREFIX + "XOR_VB" + POSTFIX;
2553     static {
2554         vectorNode(XOR_VB, "XorV", TYPE_BYTE);
2555     }
2556 
2557     public static final String XOR_VS = VECTOR_PREFIX + "XOR_VS" + POSTFIX;
2558     static {
2559         vectorNode(XOR_VS, "XorV", TYPE_SHORT);
2560     }
2561 
2562     public static final String XOR_VI = VECTOR_PREFIX + "XOR_VI" + POSTFIX;
2563     static {
2564         vectorNode(XOR_VI, "XorV", TYPE_INT);
2565     }
2566 
2567     public static final String XOR_VL = VECTOR_PREFIX + "XOR_VL" + POSTFIX;
2568     static {
2569         vectorNode(XOR_VL, "XorV", TYPE_LONG);
2570     }
2571 
2572     public static final String XOR_V_MASK = PREFIX + "XOR_V_MASK" + POSTFIX;
2573     static {
2574         beforeMatchingNameRegex(XOR_V_MASK, "XorVMask");
2575     }
2576 
2577     public static final String XOR_REDUCTION_V = PREFIX + "XOR_REDUCTION_V" + POSTFIX;
2578     static {
2579         superWordNodes(XOR_REDUCTION_V, "XorReductionV");
2580     }
2581 
2582     public static final String XOR3_NEON = PREFIX + "XOR3_NEON" + POSTFIX;
2583     static {
2584         machOnlyNameRegex(XOR3_NEON, "veor3_neon");
2585     }
2586 
2587     public static final String XOR3_SVE = PREFIX + "XOR3_SVE" + POSTFIX;
2588     static {
2589         machOnlyNameRegex(XOR3_SVE, "veor3_sve");
2590     }
2591 
2592     public static final String COMPRESS_BITS_VI = VECTOR_PREFIX + "COMPRESS_BITS_VI" + POSTFIX;
2593     static {
2594         vectorNode(COMPRESS_BITS_VI, "CompressBitsV", TYPE_INT);
2595     }
2596 
2597     public static final String COMPRESS_BITS_VL = VECTOR_PREFIX + "COMPRESS_BITS_VL" + POSTFIX;
2598     static {
2599         vectorNode(COMPRESS_BITS_VL, "CompressBitsV", TYPE_LONG);
2600     }
2601 
2602     public static final String EXPAND_BITS_VI = VECTOR_PREFIX + "EXPAND_BITS_VI" + POSTFIX;
2603     static {
2604         vectorNode(EXPAND_BITS_VI, "ExpandBitsV", TYPE_INT);
2605     }
2606 
2607     public static final String EXPAND_BITS_VL = VECTOR_PREFIX + "EXPAND_BITS_VL" + POSTFIX;
2608     static {
2609         vectorNode(EXPAND_BITS_VL, "ExpandBitsV", TYPE_LONG);
2610     }
2611 
2612     public static final String Z_LOAD_P_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "Z_LOAD_P_WITH_BARRIER_FLAG" + POSTFIX;
2613     static {
2614         String regex = START + "zLoadP\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
2615         machOnly(Z_LOAD_P_WITH_BARRIER_FLAG, regex);
2616     }
2617 
2618     public static final String Z_STORE_P_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "Z_STORE_P_WITH_BARRIER_FLAG" + POSTFIX;
2619     static {
2620         String regex = START + "zStoreP\\S*" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
2621         machOnly(Z_STORE_P_WITH_BARRIER_FLAG, regex);
2622     }
2623 
2624     public static final String Z_COMPARE_AND_SWAP_P_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "Z_COMPARE_AND_SWAP_P_WITH_BARRIER_FLAG" + POSTFIX;
2625     static {
2626         String regex = START + "zCompareAndSwapP" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
2627         machOnly(Z_COMPARE_AND_SWAP_P_WITH_BARRIER_FLAG, regex);
2628     }
2629 
2630     public static final String Z_GET_AND_SET_P_WITH_BARRIER_FLAG = COMPOSITE_PREFIX + "Z_GET_AND_SET_P_WITH_BARRIER_FLAG" + POSTFIX;
2631     static {
2632         String regex = START + "(zXChgP)|(zGetAndSetP\\S*)" + MID + "barrier\\(\\s*" + IS_REPLACED + "\\s*\\)" + END;
2633         machOnly(Z_GET_AND_SET_P_WITH_BARRIER_FLAG, regex);
2634     }
2635 
2636     public static final String X86_LOCK_ADDB_REG = PREFIX + "X86_LOCK_ADDB_REG" + POSTFIX;
2637     static {
2638         machOnlyNameRegex(X86_LOCK_ADDB_REG, "xaddB_reg_no_res");
2639     }
2640 
2641     public static final String X86_LOCK_ADDB_IMM = PREFIX + "X86_LOCK_ADDB_IMM" + POSTFIX;
2642     static {
2643         machOnlyNameRegex(X86_LOCK_ADDB_IMM, "xaddB_imm_no_res");
2644     }
2645 
2646     public static final String X86_LOCK_XADDB = PREFIX + "X86_LOCK_XADDB" + POSTFIX;
2647     static {
2648         machOnlyNameRegex(X86_LOCK_XADDB, "xaddB");
2649     }
2650 
2651     public static final String X86_LOCK_ADDS_REG = PREFIX + "X86_LOCK_ADDS_REG" + POSTFIX;
2652     static {
2653         machOnlyNameRegex(X86_LOCK_ADDS_REG, "xaddS_reg_no_res");
2654     }
2655 
2656     public static final String X86_LOCK_ADDS_IMM = PREFIX + "X86_LOCK_ADDS_IMM" + POSTFIX;
2657     static {
2658         machOnlyNameRegex(X86_LOCK_ADDS_IMM, "xaddS_imm_no_res");
2659     }
2660 
2661     public static final String X86_LOCK_XADDS = PREFIX + "X86_LOCK_XADDS" + POSTFIX;
2662     static {
2663         machOnlyNameRegex(X86_LOCK_XADDS, "xaddS");
2664     }
2665 
2666     public static final String X86_LOCK_ADDI_REG = PREFIX + "X86_LOCK_ADDI_REG" + POSTFIX;
2667     static {
2668         machOnlyNameRegex(X86_LOCK_ADDI_REG, "xaddI_reg_no_res");
2669     }
2670 
2671     public static final String X86_LOCK_ADDI_IMM = PREFIX + "X86_LOCK_ADDI_IMM" + POSTFIX;
2672     static {
2673         machOnlyNameRegex(X86_LOCK_ADDI_IMM, "xaddI_imm_no_res");
2674     }
2675 
2676     public static final String X86_LOCK_XADDI = PREFIX + "X86_LOCK_XADDI" + POSTFIX;
2677     static {
2678         machOnlyNameRegex(X86_LOCK_XADDI, "xaddI");
2679     }
2680 
2681     public static final String X86_LOCK_ADDL_REG = PREFIX + "X86_LOCK_ADDL_REG" + POSTFIX;
2682     static {
2683         machOnlyNameRegex(X86_LOCK_ADDL_REG, "xaddL_reg_no_res");
2684     }
2685 
2686     public static final String X86_LOCK_ADDL_IMM = PREFIX + "X86_LOCK_ADDL_IMM" + POSTFIX;
2687     static {
2688         machOnlyNameRegex(X86_LOCK_ADDL_IMM, "xaddL_imm_no_res");
2689     }
2690 
2691     public static final String X86_LOCK_XADDL = PREFIX + "X86_LOCK_XADDL" + POSTFIX;
2692     static {
2693         machOnlyNameRegex(X86_LOCK_XADDL, "xaddL");
2694     }
2695 
2696     public static final String X86_TESTI_REG = PREFIX + "X86_TESTI_REG" + POSTFIX;
2697     static {
2698         machOnlyNameRegex(X86_TESTI_REG, "testI_reg");
2699     }
2700 
2701     public static final String X86_TESTL_REG = PREFIX + "X86_TESTL_REG" + POSTFIX;
2702     static {
2703         machOnlyNameRegex(X86_TESTL_REG, "testL_reg");
2704     }
2705 
2706     public static final String X86_CMOVEL_IMM01 = PREFIX + "X86_CMOVEL_IMM01" + POSTFIX;
2707     static {
2708         machOnlyNameRegex(X86_CMOVEL_IMM01, "cmovL_imm_01");
2709     }
2710 
2711     public static final String X86_CMOVEL_IMM01U = PREFIX + "X86_CMOVEL_IMM01U" + POSTFIX;
2712     static {
2713         machOnlyNameRegex(X86_CMOVEL_IMM01U, "cmovL_imm_01U");
2714     }
2715 
2716     public static final String X86_CMOVEL_IMM01UCF = PREFIX + "X86_CMOVEL_IMM01UCF" + POSTFIX;
2717     static {
2718         machOnlyNameRegex(X86_CMOVEL_IMM01UCF, "cmovL_imm_01UCF");
2719     }
2720 
2721     public static final String MOD_F = PREFIX + "MOD_F" + POSTFIX;
2722     static {
2723         String regex = START + "ModF" + MID + END;
2724         macroNodes(MOD_F, regex);
2725     }
2726 
2727     public static final String MOD_D = PREFIX + "MOD_D" + POSTFIX;
2728     static {
2729         String regex = START + "ModD" + MID + END;
2730         macroNodes(MOD_D, regex);
2731     }
2732 
2733     public static final String BLACKHOLE = PREFIX + "BLACKHOLE" + POSTFIX;
2734     static {
2735         fromBeforeRemoveUselessToFinalCode(BLACKHOLE, "Blackhole");
2736     }
2737 
2738     /*
2739      * Utility methods to set up IR_NODE_MAPPINGS.
2740      */
2741 
2742     /**
2743      * Apply {@code regex} on all machine independent ideal graph phases up to and including
2744      * {@link CompilePhase#BEFORE_MATCHING}.
2745      */
2746     public static void beforeMatching(String irNodePlaceholder, String regex) {
2747         IR_NODE_MAPPINGS.put(irNodePlaceholder, new RegexTypeEntry(RegexType.IDEAL_INDEPENDENT, regex));
2748     }
2749 
2750     /**
2751      * Apply {@code irNodeRegex} as regex for the IR node name on all machine independent ideal graph phases up to and
2752      * including {@link CompilePhase#BEFORE_MATCHING}.
2753      */
2754     private static void beforeMatchingNameRegex(String irNodePlaceholder, String irNodeRegex) {
2755         String regex = START + irNodeRegex + MID + END;
2756         IR_NODE_MAPPINGS.put(irNodePlaceholder, new RegexTypeEntry(RegexType.IDEAL_INDEPENDENT, regex));
2757     }
2758 
2759     /**
2760      * Apply {@code irNodeRegex} as regex for the IR vector node name on all machine independent ideal graph phases up to and
2761      * including {@link CompilePhase#BEFORE_MATCHING}. Since this is a vector node, we can also check the vector element
2762      * type {@code typeString} and the vector size (number of elements), {@see VECTOR_SIZE}.
2763      */
2764     private static void vectorNode(String irNodePlaceholder, String irNodeRegex, String typeString) {
2765         TestFramework.check(isVectorIRNode(irNodePlaceholder), "vectorNode: failed prefix check for irNodePlaceholder "
2766                                                                + irNodePlaceholder + " -> did you use VECTOR_PREFIX?");
2767         // IS_REPLACED is later replaced with the specific type and size of the vector.
2768         String regex = START + irNodeRegex + MID  + IS_REPLACED + END;
2769         IR_NODE_MAPPINGS.put(irNodePlaceholder, new RegexTypeEntry(RegexType.IDEAL_INDEPENDENT, regex));
2770         VECTOR_NODE_TYPE.put(irNodePlaceholder, typeString);
2771     }
2772 
2773     /**
2774      * Apply {@code regex} on all ideal graph phases up to and including {@link CompilePhase#BEFORE_MACRO_EXPANSION}.
2775      */
2776     private static void macroNodes(String irNodePlaceholder, String regex) {
2777         IR_NODE_MAPPINGS.put(irNodePlaceholder, new SinglePhaseRangeEntry(CompilePhase.BEFORE_MACRO_EXPANSION, regex,
2778                                                                           CompilePhase.BEFORE_STRINGOPTS,
2779                                                                           CompilePhase.BEFORE_MACRO_EXPANSION));
2780     }
2781 
2782     private static void callOfNodes(String irNodePlaceholder, String callRegex) {
2783         String regex = START + callRegex + MID + IS_REPLACED + " " +  END;
2784         IR_NODE_MAPPINGS.put(irNodePlaceholder, new RegexTypeEntry(RegexType.IDEAL_INDEPENDENT, regex));
2785     }
2786 
2787     /**
2788      * Apply {@code regex} on all machine dependant ideal graph phases (i.e. on the mach graph) starting from
2789      * {@link CompilePhase#MATCHING}.
2790      */
2791     public static void optoOnly(String irNodePlaceholder, String regex) {
2792         IR_NODE_MAPPINGS.put(irNodePlaceholder, new RegexTypeEntry(RegexType.OPTO_ASSEMBLY, regex));
2793     }
2794 
2795     private static void machOnly(String irNodePlaceholder, String regex) {
2796         IR_NODE_MAPPINGS.put(irNodePlaceholder, new RegexTypeEntry(RegexType.MACH, regex));
2797     }
2798 
2799     private static void machOnlyNameRegex(String irNodePlaceholder, String irNodeRegex) {
2800         String regex = START + irNodeRegex + MID + END;
2801         IR_NODE_MAPPINGS.put(irNodePlaceholder, new RegexTypeEntry(RegexType.MACH, regex));
2802     }
2803 
2804     /**
2805      * Apply {@code regex} on all ideal graph phases starting from {@link CompilePhase#AFTER_CLOOPS}.
2806      */
2807     private static void fromAfterCountedLoops(String irNodePlaceholder, String regex) {
2808         IR_NODE_MAPPINGS.put(irNodePlaceholder, new SinglePhaseRangeEntry(CompilePhase.PRINT_IDEAL, regex,
2809                                                                           CompilePhase.AFTER_CLOOPS,
2810                                                                           CompilePhase.FINAL_CODE));
2811     }
2812 
2813     /**
2814      * Apply {@code regex} on all ideal graph phases starting from {@link CompilePhase#BEFORE_CLOOPS}.
2815      */
2816     private static void fromBeforeCountedLoops(String irNodePlaceholder, String regex) {
2817         IR_NODE_MAPPINGS.put(irNodePlaceholder, new SinglePhaseRangeEntry(CompilePhase.PRINT_IDEAL, regex,
2818                                                                           CompilePhase.BEFORE_CLOOPS,
2819                                                                           CompilePhase.FINAL_CODE));
2820     }
2821 
2822     /**
2823      * Apply {@code regex} on all ideal graph phases starting from {@link CompilePhase#BEFORE_CLOOPS} up to and
2824      * including {@link CompilePhase#BEFORE_MATCHING}
2825      */
2826     private static void fromMacroToBeforeMatching(String irNodePlaceholder, String regex) {
2827         IR_NODE_MAPPINGS.put(irNodePlaceholder, new SinglePhaseRangeEntry(CompilePhase.PRINT_IDEAL, regex,
2828                                                                           CompilePhase.AFTER_MACRO_EXPANSION,
2829                                                                           CompilePhase.BEFORE_MATCHING));
2830     }
2831 
2832     /**
2833      * Apply {@code regex} on all ideal graph phases starting from {@link CompilePhase#BEFORE_CLOOPS} up to and
2834      * including {@link CompilePhase#BEFORE_MATCHING}
2835      */
2836     private static void afterBarrierExpansionToBeforeMatching(String irNodePlaceholder, String regex) {
2837         IR_NODE_MAPPINGS.put(irNodePlaceholder, new SinglePhaseRangeEntry(CompilePhase.PRINT_IDEAL, regex,
2838                                                                           CompilePhase.OPTIMIZE_FINISHED,
2839                                                                           CompilePhase.BEFORE_MATCHING));
2840     }
2841 
2842     private static void trapNodes(String irNodePlaceholder, String trapReason) {
2843         String regex = START + "CallStaticJava" + MID + "uncommon_trap.*" + trapReason + END;
2844         beforeMatching(irNodePlaceholder, regex);
2845     }
2846 
2847     private static void parsePredicateNodes(String irNodePlaceholder, String label) {
2848         String regex = START + "ParsePredicate" + MID + "#" + label + "[ ]*!jvms:" + END;
2849         IR_NODE_MAPPINGS.put(irNodePlaceholder, new SinglePhaseRangeEntry(CompilePhase.AFTER_PARSING, regex,
2850                                                                           CompilePhase.AFTER_PARSING,
2851                                                                           CompilePhase.PHASEIDEALLOOP_ITERATIONS));
2852     }
2853 
2854     private static void loadOfNodes(String irNodePlaceholder, String irNodeRegex) {
2855         String regex = START + irNodeRegex + MID + "@\\S*" + IS_REPLACED + LOAD_OF_CLASS_POSTFIX;
2856         beforeMatching(irNodePlaceholder, regex);
2857     }
2858 
2859     private static void storeOfNodes(String irNodePlaceholder, String irNodeRegex) {
2860         String regex = START + irNodeRegex + MID + "@\\S*" + IS_REPLACED + STORE_OF_CLASS_POSTFIX;
2861         beforeMatching(irNodePlaceholder, regex);
2862     }
2863 
2864     private static void fromBeforeRemoveUselessToFinalCode(String irNodePlaceholder, String irNodeRegex) {
2865         String regex = START + irNodeRegex + MID + END;
2866         IR_NODE_MAPPINGS.put(irNodePlaceholder, new SinglePhaseRangeEntry(CompilePhase.PRINT_IDEAL, regex,
2867                 CompilePhase.BEFORE_REMOVEUSELESS,
2868                 CompilePhase.FINAL_CODE));
2869     }
2870 
2871     /**
2872      * Apply {@code regex} on all ideal graph phases starting from {@link CompilePhase#PHASEIDEALLOOP1} which is the
2873      * first phase that could contain vector nodes from super word.
2874      */
2875     private static void superWordNodes(String irNodePlaceholder, String irNodeRegex) {
2876         String regex = START + irNodeRegex + MID + END;
2877         IR_NODE_MAPPINGS.put(irNodePlaceholder, new SinglePhaseRangeEntry(CompilePhase.PRINT_IDEAL, regex,
2878                                                                           CompilePhase.PHASEIDEALLOOP1,
2879                                                                           CompilePhase.BEFORE_MATCHING));
2880     }
2881 
2882 
2883     /*
2884      * Methods used internally by the IR framework.
2885      */
2886 
2887     /**
2888      * Is {@code irNodeString} an IR node placeholder string?
2889      */
2890     public static boolean isIRNode(String irNodeString) {
2891         return irNodeString.startsWith(PREFIX);
2892     }
2893 
2894     /**
2895      * Is {@code irCompositeNodeString} an IR composite node placeholder string?
2896      */
2897     public static boolean isCompositeIRNode(String irCompositeNodeString) {
2898         return irCompositeNodeString.startsWith(COMPOSITE_PREFIX);
2899     }
2900 
2901     /**
2902      * Is {@code irVectorNodeString} an IR vector node placeholder string?
2903      */
2904     public static boolean isVectorIRNode(String irVectorNodeString) {
2905         return irVectorNodeString.startsWith(VECTOR_PREFIX);
2906     }
2907 
2908     /**
2909      * Is {@code irVectorSizeString} a vector size string?
2910      */
2911     public static boolean isVectorSize(String irVectorSizeString) {
2912         return irVectorSizeString.startsWith(VECTOR_SIZE);
2913     }
2914 
2915     /**
2916      * Parse {@code sizeString} and generate a regex pattern to match for the size in the IR dump.
2917      */
2918     public static String parseVectorNodeSize(String sizeString, String typeString, VMInfo vmInfo) {
2919         if (sizeString.equals(VECTOR_SIZE_TAG_ANY)) {
2920             return "\\\\d+"; // match with any number
2921         }
2922         // Try to parse any tags, convert to comma separated list of ints
2923         sizeString = parseVectorNodeSizeTag(sizeString, typeString, vmInfo);
2924         // Parse comma separated list of numbers
2925         String[] sizes = sizeString.split(",");
2926         String regex = "";
2927         for (int i = 0; i < sizes.length; i++) {
2928             int size = 0;
2929             try {
2930                 size = Integer.parseInt(sizes[i]);
2931             } catch (NumberFormatException e) {
2932                 throw new TestFormatException("Vector node has invalid size \"" + sizes[i] + "\", in \"" + sizeString + "\"");
2933             }
2934             TestFormat.checkNoReport(size > 1, "Vector node size must be 2 or larger, but got \"" + sizes[i] + "\", in \"" + sizeString + "\"");
2935             regex += ((i > 0) ? "|" : "") + size;
2936         }
2937         if (sizes.length > 1) {
2938            regex = "(" + regex + ")";
2939         }
2940         return regex;
2941     }
2942 
2943     /**
2944      * If {@code sizeTagString} is a size tag, return the list of accepted sizes, else return sizeTagString.
2945      */
2946     public static String parseVectorNodeSizeTag(String sizeTagString, String typeString, VMInfo vmInfo) {
2947         // Parse out "min(a,b,c,...)"
2948         if (sizeTagString.startsWith("min(") && sizeTagString.endsWith(")")) {
2949             return parseVectorNodeSizeTagMin(sizeTagString, typeString, vmInfo);
2950         }
2951 
2952         // Parse individual tags
2953         return switch (sizeTagString) {
2954             case VECTOR_SIZE_TAG_MAX -> String.valueOf(getMaxElementsForType(typeString, vmInfo));
2955             case "max_byte"          -> String.valueOf(getMaxElementsForType(TYPE_BYTE, vmInfo));
2956             case "max_char"          -> String.valueOf(getMaxElementsForType(TYPE_CHAR, vmInfo));
2957             case "max_short"         -> String.valueOf(getMaxElementsForType(TYPE_SHORT, vmInfo));
2958             case "max_int"           -> String.valueOf(getMaxElementsForType(TYPE_INT, vmInfo));
2959             case "max_long"          -> String.valueOf(getMaxElementsForType(TYPE_LONG, vmInfo));
2960             case "max_float"         -> String.valueOf(getMaxElementsForType(TYPE_FLOAT, vmInfo));
2961             case "max_double"        -> String.valueOf(getMaxElementsForType(TYPE_DOUBLE, vmInfo));
2962             case "LoopMaxUnroll"     -> String.valueOf(vmInfo.getLongValue("LoopMaxUnroll"));
2963             default                  -> sizeTagString;
2964         };
2965     }
2966 
2967     /**
2968      * Parse {@code sizeTagString}, which must be a min-clause.
2969      */
2970     public static String parseVectorNodeSizeTagMin(String sizeTagString, String typeString, VMInfo vmInfo) {
2971         String[] tags = sizeTagString.substring(4, sizeTagString.length() - 1).split(",");
2972         TestFormat.checkNoReport(tags.length > 1, "Vector node size \"min(...)\" must have at least 2 comma separated arguments, got \"" + sizeTagString + "\"");
2973         int minVal = 1024;
2974         for (int i = 0; i < tags.length; i++) {
2975             String tag = parseVectorNodeSizeTag(tags[i].trim(), typeString, vmInfo);
2976             int tag_val = 0;
2977             try {
2978                 tag_val = Integer.parseInt(tag);
2979             } catch (NumberFormatException e) {
2980                 throw new TestFormatException("Vector node has invalid size in \"min(...)\", argument " + i + ", \"" + tag + "\", in \"" + sizeTagString + "\"");
2981             }
2982             minVal = Math.min(minVal, tag_val);
2983         }
2984         return String.valueOf(minVal);
2985     }
2986 
2987     /**
2988      * Return maximal number of elements that can fit in a vector of the specified type.
2989      */
2990     public static long getMaxElementsForType(String typeString, VMInfo vmInfo) {
2991         long maxVectorSize = vmInfo.getLongValue("MaxVectorSize");
2992         TestFormat.checkNoReport(maxVectorSize > 0, "VMInfo: MaxVectorSize is not larger than zero");
2993         long maxBytes = maxVectorSize;
2994 
2995         if (Platform.isX64() || Platform.isX86()) {
2996             maxBytes = Math.min(maxBytes, getMaxElementsForTypeOnX86(typeString, vmInfo));
2997         }
2998 
2999         // compute elements per vector: vector bytes divided by bytes per element
3000         int bytes = getTypeSizeInBytes(typeString);
3001         return maxBytes / bytes;
3002     }
3003 
3004     /**
3005      * Return maximal number of elements that can fit in a vector of the specified type, on x86 / x64.
3006      */
3007     public static long getMaxElementsForTypeOnX86(String typeString, VMInfo vmInfo) {
3008         // restrict maxBytes for specific features, see Matcher::vector_width_in_bytes in x86.ad:
3009         boolean avx1 = vmInfo.hasCPUFeature("avx");
3010         boolean avx2 = vmInfo.hasCPUFeature("avx2");
3011         boolean avx512 = vmInfo.hasCPUFeature("avx512f");
3012         boolean avx512bw = vmInfo.hasCPUFeature("avx512bw");
3013         long maxBytes;
3014         if (avx512) {
3015             maxBytes = 64;
3016         } else if (avx2) {
3017             maxBytes = 32;
3018         } else {
3019             maxBytes = 16;
3020         }
3021         if (avx1 && (typeString.equals(TYPE_FLOAT) || typeString.equals(TYPE_DOUBLE))) {
3022             maxBytes = avx512 ? 64 : 32;
3023         }
3024         if (avx512 && (typeString.equals(TYPE_BYTE) || typeString.equals(TYPE_SHORT) || typeString.equals(TYPE_CHAR))) {
3025             maxBytes = avx512bw ? 64 : 32;
3026         }
3027 
3028         return maxBytes;
3029     }
3030 
3031     /**
3032      * Return size in bytes of type named by {@code typeString}, return 0 if it does not name a type.
3033      */
3034     public static int getTypeSizeInBytes(String typeString) {
3035         return switch (typeString) {
3036             case TYPE_BYTE              -> 1;
3037             case TYPE_CHAR, TYPE_SHORT  -> 2;
3038             case TYPE_INT, TYPE_FLOAT   -> 4;
3039             case TYPE_LONG, TYPE_DOUBLE -> 8;
3040             default                     -> 0;
3041         };
3042     }
3043 
3044     /**
3045      * Returns "IRNode.XYZ", where XYZ is one of the IR node placeholder variable names defined above.
3046      */
3047     public static String getIRNodeAccessString(String irNodeString) {
3048         int prefixLength;
3049         if (isCompositeIRNode(irNodeString)) {
3050             TestFramework.check(irNodeString.length() > COMPOSITE_PREFIX.length() + POSTFIX.length(),
3051                                 "Invalid composite node placeholder: " + irNodeString);
3052             prefixLength = COMPOSITE_PREFIX.length();
3053         } else if (isVectorIRNode(irNodeString)) {
3054             TestFramework.check(irNodeString.length() > VECTOR_PREFIX.length() + POSTFIX.length(),
3055                                 "Invalid vector node placeholder: " + irNodeString);
3056             prefixLength = VECTOR_PREFIX.length();
3057         } else {
3058             prefixLength = PREFIX.length();
3059         }
3060         return "IRNode." + irNodeString.substring(prefixLength, irNodeString.length() - POSTFIX.length());
3061     }
3062 
3063     /**
3064      * Is this IR node supported on current platform, used VM build, etc.?
3065      * Throws a {@link CheckedTestFrameworkException} if the IR node is unsupported.
3066      */
3067     public static void checkIRNodeSupported(String node) throws CheckedTestFrameworkException {
3068         switch (node) {
3069             case INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP -> {
3070                 if (!WhiteBox.getWhiteBox().isJVMCISupportedByGC()) {
3071                     throw new CheckedTestFrameworkException("INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP is unsupported " +
3072                                                             "in builds without JVMCI.");
3073                 }
3074             }
3075             case CHECKCAST_ARRAYCOPY -> {
3076                 if (Platform.isS390x()) {
3077                     throw new CheckedTestFrameworkException("CHECKCAST_ARRAYCOPY is unsupported on s390.");
3078                 }
3079             }
3080             case IS_FINITE_D, IS_FINITE_F -> {
3081                 if (!Platform.isRISCV64()) {
3082                     throw new CheckedTestFrameworkException("IS_FINITE_* is only supported on riscv64.");
3083                 }
3084             }
3085             // default: do nothing -> IR node is supported and can be used by the user.
3086         }
3087     }
3088 
3089     /**
3090      * Get the regex of an IR node for a specific compile phase. If {@code irNode} is not an IR node placeholder string
3091      * or if there is no regex specified for {@code compilePhase}, a {@link TestFormatException} is reported.
3092      */
3093     public static String getRegexForCompilePhase(String irNode, CompilePhase compilePhase) {
3094         IRNodeMapEntry entry = IR_NODE_MAPPINGS.get(irNode);
3095         String failMsg = "IR Node \"" + irNode + "\" defined in class IRNode has no regex/compiler phase mapping " +
3096                          "(i.e. no static initializer block that adds a mapping entry to IRNode.IR_NODE_MAPPINGS)." +
3097                          System.lineSeparator() +
3098                          "   Have you just created the entry \"" + irNode + "\" in class IRNode and forgot to add a " +
3099                          "mapping?" + System.lineSeparator() +
3100                          "   Violation";
3101         TestFormat.checkNoReport(entry != null, failMsg);
3102         String regex = entry.regexForCompilePhase(compilePhase);
3103         failMsg = "IR Node \"" + irNode + "\" defined in class IRNode has no regex defined for compile phase "
3104                   + compilePhase + "." + System.lineSeparator() +
3105                   "   If you think this compile phase should be supported, update the mapping for \"" + irNode +
3106                   "\" in class IRNode (i.e the static initializer block immediately following the definition of \"" +
3107                   irNode + "\")." + System.lineSeparator() +
3108                   "   Violation";
3109         TestFormat.checkNoReport(regex != null, failMsg);
3110         return regex;
3111     }
3112 
3113     /**
3114      * Get the default phase of an IR node. If {@code irNode} is not an IR node placeholder string, a
3115      * {@link TestFormatException} is reported.
3116      */
3117     public static CompilePhase getDefaultPhase(String irNode) {
3118         IRNodeMapEntry entry = IR_NODE_MAPPINGS.get(irNode);
3119         String failMsg = "\"" + irNode + "\" is not an IR node defined in class IRNode and " +
3120                          "has therefore no default compile phase specified." + System.lineSeparator() +
3121                          "   If your regex represents a C2 IR node, consider adding an entry to class IRNode together " +
3122                          "with a static initializer block that adds a mapping to IRNode.IR_NODE_MAPPINGS." +
3123                          System.lineSeparator() +
3124                          "   Otherwise, set the @IR \"phase\" attribute to a compile phase different from " +
3125                          "CompilePhase.DEFAULT to explicitly tell the IR framework on which compile phase your rule" +
3126                          " should be applied on." + System.lineSeparator() +
3127                          "   Violation";
3128         TestFormat.checkNoReport(entry != null, failMsg);
3129         return entry.defaultCompilePhase();
3130     }
3131 
3132     public static String getVectorNodeType(String irNode) {
3133         String typeString = VECTOR_NODE_TYPE.get(irNode);
3134         String failMsg = "\"" + irNode + "\" is not a Vector IR node defined in class IRNode";
3135         TestFormat.check(typeString != null, failMsg);
3136         return typeString;
3137     }
3138 }