001
002/*
003 * THIS FILE IS MACHINE_GENERATED. DO NOT EDIT.
004 * See InstructionFormats.template, InstructionFormatList.dat,
005 * OperatorList.dat, etc.
006 */
007
008package org.jikesrvm.compilers.opt.ir;
009
010import org.jikesrvm.Configuration;
011import org.jikesrvm.compilers.opt.ir.operand.*;
012
013/**
014 * The Return InstructionFormat class.
015 *
016 * The header comment for {@link Instruction} contains
017 * an explanation of the role of InstructionFormats in the
018 * opt compiler's IR.
019 */
020@SuppressWarnings("unused")  // Machine generated code is never 100% clean
021public final class Return extends InstructionFormat {
022  /**
023   * InstructionFormat identification method for Return.
024   * @param i an instruction
025   * @return <code>true</code> if the InstructionFormat of the argument
026   *         instruction is Return or <code>false</code>
027   *         if it is not.
028   */
029  public static boolean conforms(Instruction i) {
030    return conforms(i.operator());
031  }
032  /**
033   * InstructionFormat identification method for Return.
034   * @param o an instruction
035   * @return <code>true</code> if the InstructionFormat of the argument
036   *         operator is Return or <code>false</code>
037   *         if it is not.
038   */
039  public static boolean conforms(Operator o) {
040    return o.format == Return_format;
041  }
042
043  /**
044   * Get the operand called Val from the
045   * argument instruction. Note that the returned operand
046   * will still point to its containing instruction.
047   * @param i the instruction to fetch the operand from
048   * @return the operand called Val
049   */
050  public static Operand getVal(Instruction i) {
051    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Return");
052    return (Operand) i.getOperand(0);
053  }
054  /**
055   * Get the operand called Val from the argument
056   * instruction clearing its instruction pointer. The returned
057   * operand will not point to any containing instruction.
058   * @param i the instruction to fetch the operand from
059   * @return the operand called Val
060   */
061  public static Operand getClearVal(Instruction i) {
062    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Return");
063    return (Operand) i.getClearOperand(0);
064  }
065  /**
066   * Set the operand called Val in the argument
067   * instruction to the argument operand. The operand will
068   * now point to the argument instruction as its containing
069   * instruction.
070   * @param i the instruction in which to store the operand
071   * @param Val the operand to store
072   */
073  public static void setVal(Instruction i, Operand Val) {
074    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Return");
075    i.putOperand(0, Val);
076  }
077  /**
078   * Return the index of the operand called Val
079   * in the argument instruction.
080   * @param i the instruction to access.
081   * @return the index of the operand called Val
082   *         in the argument instruction
083   */
084  public static int indexOfVal(Instruction i) {
085    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Return");
086    return 0;
087  }
088  /**
089   * Does the argument instruction have a non-null
090   * operand named Val?
091   * @param i the instruction to access.
092   * @return <code>true</code> if the instruction has an non-null
093   *         operand named Val or <code>false</code>
094   *         if it does not.
095   */
096  public static boolean hasVal(Instruction i) {
097    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "Return");
098    return i.getOperand(0) != null;
099  }
100
101
102  /**
103   * Create an instruction of the Return instruction format.
104   * @param o the instruction's operator
105   * @param Val the instruction's Val operand
106   * @return the newly created Return instruction
107   */
108  public static Instruction create(Operator o
109                   , Operand Val
110                )
111  {
112    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "Return");
113    Instruction i = Instruction.create(o, 5);
114    i.putOperand(0, Val);
115    return i;
116  }
117
118  /**
119   * Mutate the argument instruction into an instruction of the
120   * Return instruction format having the specified
121   * operator and operands.
122   * @param i the instruction to mutate
123   * @param o the instruction's operator
124   * @param Val the instruction's Val operand
125   * @return the mutated instruction
126   */
127  public static Instruction mutate(Instruction i, Operator o
128                   , Operand Val
129                )
130  {
131    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "Return");
132    i.changeOperatorTo(o);
133    i.putOperand(0, Val);
134    return i;
135  }
136  /**
137   * Create an instruction of the Return instruction format.
138   * @param o the instruction's operator
139   * @return the newly created Return instruction
140   */
141  public static Instruction create(Operator o
142                )
143  {
144    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "Return");
145    Instruction i = Instruction.create(o, 5);
146    return i;
147  }
148
149  /**
150   * Mutate the argument instruction into an instruction of the
151   * Return instruction format having the specified
152   * operator and operands.
153   * @param i the instruction to mutate
154   * @param o the instruction's operator
155   * @return the mutated instruction
156   */
157  public static Instruction mutate(Instruction i, Operator o
158                )
159  {
160    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "Return");
161    i.changeOperatorTo(o);
162    i.putOperand(0, null);
163    return i;
164  }
165}
166