/* * THIS FILE IS MACHINE_GENERATED. DO NOT EDIT. * See InstructionFormats.template, InstructionFormatList.dat, * OperatorList.dat, etc. */ package org.jikesrvm.compilers.opt.ir; import org.jikesrvm.VM_Configuration; import org.jikesrvm.compilers.opt.ir.ia32.OPT_IA32ConditionOperand; //NOPMD /** * The Binary InstructionFormat class. * * The header comment for {@link OPT_Instruction} contains * an explanation of the role of InstructionFormats in the * opt compiler's IR. */ @SuppressWarnings("unused") // Machine generated code is never 100% clean public final class Binary extends OPT_InstructionFormat { /** * InstructionFormat identification method for Binary. * @param i an instruction * @return <code>true</code> if the InstructionFormat of the argument * instruction is Binary or <code>false</code> * if it is not. */ public static boolean conforms(OPT_Instruction i) { return conforms(i.operator); } /** * InstructionFormat identification method for Binary. * @param o an instruction * @return <code>true</code> if the InstructionFormat of the argument * operator is Binary or <code>false</code> * if it is not. */ public static boolean conforms(OPT_Operator o) { return o.format == Binary_format; } /** * Get the operand called Result from the * argument instruction. Note that the returned operand * will still point to its containing instruction. * @param i the instruction to fetch the operand from * @return the operand called Result */ public static OPT_RegisterOperand getResult(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return (OPT_RegisterOperand) i.getOperand(0); } /** * Get the operand called Result from the argument * instruction clearing its instruction pointer. The returned * operand will not point to any containing instruction. * @param i the instruction to fetch the operand from * @return the operand called Result */ public static OPT_RegisterOperand getClearResult(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return (OPT_RegisterOperand) i.getClearOperand(0); } /** * Set the operand called Result in the argument * instruction to the argument operand. The operand will * now point to the argument instruction as its containing * instruction. * @param i the instruction in which to store the operand * @param Result the operand to store */ public static void setResult(OPT_Instruction i, OPT_RegisterOperand Result) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); i.putOperand(0, Result); } /** * Return the index of the operand called Result * in the argument instruction. * @param i the instruction to access. * @return the index of the operand called Result * in the argument instruction */ public static int indexOfResult(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return 0; } /** * Does the argument instruction have a non-null * operand named Result? * @param i the instruction to access. * @return <code>true</code> if the instruction has an non-null * operand named Result or <code>false</code> * if it does not. */ public static boolean hasResult(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return i.getOperand(0) != null; } /** * Get the operand called Val1 from the * argument instruction. Note that the returned operand * will still point to its containing instruction. * @param i the instruction to fetch the operand from * @return the operand called Val1 */ public static OPT_Operand getVal1(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return (OPT_Operand) i.getOperand(1); } /** * Get the operand called Val1 from the argument * instruction clearing its instruction pointer. The returned * operand will not point to any containing instruction. * @param i the instruction to fetch the operand from * @return the operand called Val1 */ public static OPT_Operand getClearVal1(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return (OPT_Operand) i.getClearOperand(1); } /** * Set the operand called Val1 in the argument * instruction to the argument operand. The operand will * now point to the argument instruction as its containing * instruction. * @param i the instruction in which to store the operand * @param Val1 the operand to store */ public static void setVal1(OPT_Instruction i, OPT_Operand Val1) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); i.putOperand(1, Val1); } /** * Return the index of the operand called Val1 * in the argument instruction. * @param i the instruction to access. * @return the index of the operand called Val1 * in the argument instruction */ public static int indexOfVal1(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return 1; } /** * Does the argument instruction have a non-null * operand named Val1? * @param i the instruction to access. * @return <code>true</code> if the instruction has an non-null * operand named Val1 or <code>false</code> * if it does not. */ public static boolean hasVal1(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return i.getOperand(1) != null; } /** * Get the operand called Val2 from the * argument instruction. Note that the returned operand * will still point to its containing instruction. * @param i the instruction to fetch the operand from * @return the operand called Val2 */ public static OPT_Operand getVal2(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return (OPT_Operand) i.getOperand(2); } /** * Get the operand called Val2 from the argument * instruction clearing its instruction pointer. The returned * operand will not point to any containing instruction. * @param i the instruction to fetch the operand from * @return the operand called Val2 */ public static OPT_Operand getClearVal2(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return (OPT_Operand) i.getClearOperand(2); } /** * Set the operand called Val2 in the argument * instruction to the argument operand. The operand will * now point to the argument instruction as its containing * instruction. * @param i the instruction in which to store the operand * @param Val2 the operand to store */ public static void setVal2(OPT_Instruction i, OPT_Operand Val2) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); i.putOperand(2, Val2); } /** * Return the index of the operand called Val2 * in the argument instruction. * @param i the instruction to access. * @return the index of the operand called Val2 * in the argument instruction */ public static int indexOfVal2(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return 2; } /** * Does the argument instruction have a non-null * operand named Val2? * @param i the instruction to access. * @return <code>true</code> if the instruction has an non-null * operand named Val2 or <code>false</code> * if it does not. */ public static boolean hasVal2(OPT_Instruction i) { if (VM_Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Binary"); return i.getOperand(2) != null; } /** * Create an instruction of the Binary instruction format. * @param o the instruction's operator * @param Result the instruction's Result operand * @param Val1 the instruction's Val1 operand * @param Val2 the instruction's Val2 operand * @return the newly created Binary instruction */ public static OPT_Instruction create(OPT_Operator o , OPT_RegisterOperand Result , OPT_Operand Val1 , OPT_Operand Val2 ) { if (VM_Configuration.ExtremeAssertions && !conforms(o)) fail(o, "Binary"); OPT_Instruction i = new OPT_Instruction(o, 5); i.putOperand(0, Result); i.putOperand(1, Val1); i.putOperand(2, Val2); return i; } /** * Mutate the argument instruction into an instruction of the * Binary instruction format having the specified * operator and operands. * @param i the instruction to mutate * @param o the instruction's operator * @param Result the instruction's Result operand * @param Val1 the instruction's Val1 operand * @param Val2 the instruction's Val2 operand * @return the mutated instruction */ public static OPT_Instruction mutate(OPT_Instruction i, OPT_Operator o , OPT_RegisterOperand Result , OPT_Operand Val1 , OPT_Operand Val2 ) { if (VM_Configuration.ExtremeAssertions && !conforms(o)) fail(o, "Binary"); i.operator = o; i.putOperand(0, Result); i.putOperand(1, Val1); i.putOperand(2, Val2); return i; } }