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.ia32;
009
010import org.jikesrvm.Configuration;
011import org.jikesrvm.compilers.opt.ir.operand.ia32.IA32ConditionOperand;
012import org.jikesrvm.compilers.opt.ir.operand.*;
013import org.jikesrvm.compilers.opt.ir.Instruction;
014import org.jikesrvm.compilers.opt.ir.Operator;
015
016/**
017 * The MIR_TrapIf InstructionFormat class.
018 *
019 * The header comment for {@link Instruction} contains
020 * an explanation of the role of InstructionFormats in the
021 * opt compiler's IR.
022 */
023@SuppressWarnings("unused")  // Machine generated code is never 100% clean
024public final class MIR_TrapIf extends ArchInstructionFormat {
025  /**
026   * InstructionFormat identification method for MIR_TrapIf.
027   * @param i an instruction
028   * @return <code>true</code> if the InstructionFormat of the argument
029   *         instruction is MIR_TrapIf or <code>false</code>
030   *         if it is not.
031   */
032  public static boolean conforms(Instruction i) {
033    return conforms(i.operator());
034  }
035  /**
036   * InstructionFormat identification method for MIR_TrapIf.
037   * @param o an instruction
038   * @return <code>true</code> if the InstructionFormat of the argument
039   *         operator is MIR_TrapIf or <code>false</code>
040   *         if it is not.
041   */
042  public static boolean conforms(Operator o) {
043    return o.format == MIR_TrapIf_format;
044  }
045
046  /**
047   * Get the operand called GuardResult from the
048   * argument instruction. Note that the returned operand
049   * will still point to its containing instruction.
050   * @param i the instruction to fetch the operand from
051   * @return the operand called GuardResult
052   */
053  public static RegisterOperand getGuardResult(Instruction i) {
054    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
055    return (RegisterOperand) i.getOperand(0);
056  }
057  /**
058   * Get the operand called GuardResult from the argument
059   * instruction clearing its instruction pointer. The returned
060   * operand will not point to any containing instruction.
061   * @param i the instruction to fetch the operand from
062   * @return the operand called GuardResult
063   */
064  public static RegisterOperand getClearGuardResult(Instruction i) {
065    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
066    return (RegisterOperand) i.getClearOperand(0);
067  }
068  /**
069   * Set the operand called GuardResult in the argument
070   * instruction to the argument operand. The operand will
071   * now point to the argument instruction as its containing
072   * instruction.
073   * @param i the instruction in which to store the operand
074   * @param GuardResult the operand to store
075   */
076  public static void setGuardResult(Instruction i, RegisterOperand GuardResult) {
077    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
078    i.putOperand(0, GuardResult);
079  }
080  /**
081   * Return the index of the operand called GuardResult
082   * in the argument instruction.
083   * @param i the instruction to access.
084   * @return the index of the operand called GuardResult
085   *         in the argument instruction
086   */
087  public static int indexOfGuardResult(Instruction i) {
088    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
089    return 0;
090  }
091  /**
092   * Does the argument instruction have a non-null
093   * operand named GuardResult?
094   * @param i the instruction to access.
095   * @return <code>true</code> if the instruction has an non-null
096   *         operand named GuardResult or <code>false</code>
097   *         if it does not.
098   */
099  public static boolean hasGuardResult(Instruction i) {
100    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
101    return i.getOperand(0) != null;
102  }
103
104  /**
105   * Get the operand called Val1 from the
106   * argument instruction. Note that the returned operand
107   * will still point to its containing instruction.
108   * @param i the instruction to fetch the operand from
109   * @return the operand called Val1
110   */
111  public static Operand getVal1(Instruction i) {
112    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
113    return (Operand) i.getOperand(1);
114  }
115  /**
116   * Get the operand called Val1 from the argument
117   * instruction clearing its instruction pointer. The returned
118   * operand will not point to any containing instruction.
119   * @param i the instruction to fetch the operand from
120   * @return the operand called Val1
121   */
122  public static Operand getClearVal1(Instruction i) {
123    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
124    return (Operand) i.getClearOperand(1);
125  }
126  /**
127   * Set the operand called Val1 in the argument
128   * instruction to the argument operand. The operand will
129   * now point to the argument instruction as its containing
130   * instruction.
131   * @param i the instruction in which to store the operand
132   * @param Val1 the operand to store
133   */
134  public static void setVal1(Instruction i, Operand Val1) {
135    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
136    i.putOperand(1, Val1);
137  }
138  /**
139   * Return the index of the operand called Val1
140   * in the argument instruction.
141   * @param i the instruction to access.
142   * @return the index of the operand called Val1
143   *         in the argument instruction
144   */
145  public static int indexOfVal1(Instruction i) {
146    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
147    return 1;
148  }
149  /**
150   * Does the argument instruction have a non-null
151   * operand named Val1?
152   * @param i the instruction to access.
153   * @return <code>true</code> if the instruction has an non-null
154   *         operand named Val1 or <code>false</code>
155   *         if it does not.
156   */
157  public static boolean hasVal1(Instruction i) {
158    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
159    return i.getOperand(1) != null;
160  }
161
162  /**
163   * Get the operand called Val2 from the
164   * argument instruction. Note that the returned operand
165   * will still point to its containing instruction.
166   * @param i the instruction to fetch the operand from
167   * @return the operand called Val2
168   */
169  public static Operand getVal2(Instruction i) {
170    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
171    return (Operand) i.getOperand(2);
172  }
173  /**
174   * Get the operand called Val2 from the argument
175   * instruction clearing its instruction pointer. The returned
176   * operand will not point to any containing instruction.
177   * @param i the instruction to fetch the operand from
178   * @return the operand called Val2
179   */
180  public static Operand getClearVal2(Instruction i) {
181    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
182    return (Operand) i.getClearOperand(2);
183  }
184  /**
185   * Set the operand called Val2 in the argument
186   * instruction to the argument operand. The operand will
187   * now point to the argument instruction as its containing
188   * instruction.
189   * @param i the instruction in which to store the operand
190   * @param Val2 the operand to store
191   */
192  public static void setVal2(Instruction i, Operand Val2) {
193    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
194    i.putOperand(2, Val2);
195  }
196  /**
197   * Return the index of the operand called Val2
198   * in the argument instruction.
199   * @param i the instruction to access.
200   * @return the index of the operand called Val2
201   *         in the argument instruction
202   */
203  public static int indexOfVal2(Instruction i) {
204    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
205    return 2;
206  }
207  /**
208   * Does the argument instruction have a non-null
209   * operand named Val2?
210   * @param i the instruction to access.
211   * @return <code>true</code> if the instruction has an non-null
212   *         operand named Val2 or <code>false</code>
213   *         if it does not.
214   */
215  public static boolean hasVal2(Instruction i) {
216    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
217    return i.getOperand(2) != null;
218  }
219
220  /**
221   * Get the operand called Cond from the
222   * argument instruction. Note that the returned operand
223   * will still point to its containing instruction.
224   * @param i the instruction to fetch the operand from
225   * @return the operand called Cond
226   */
227  public static IA32ConditionOperand getCond(Instruction i) {
228    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
229    return (IA32ConditionOperand) i.getOperand(3);
230  }
231  /**
232   * Get the operand called Cond from the argument
233   * instruction clearing its instruction pointer. The returned
234   * operand will not point to any containing instruction.
235   * @param i the instruction to fetch the operand from
236   * @return the operand called Cond
237   */
238  public static IA32ConditionOperand getClearCond(Instruction i) {
239    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
240    return (IA32ConditionOperand) i.getClearOperand(3);
241  }
242  /**
243   * Set the operand called Cond in the argument
244   * instruction to the argument operand. The operand will
245   * now point to the argument instruction as its containing
246   * instruction.
247   * @param i the instruction in which to store the operand
248   * @param Cond the operand to store
249   */
250  public static void setCond(Instruction i, IA32ConditionOperand Cond) {
251    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
252    i.putOperand(3, Cond);
253  }
254  /**
255   * Return the index of the operand called Cond
256   * in the argument instruction.
257   * @param i the instruction to access.
258   * @return the index of the operand called Cond
259   *         in the argument instruction
260   */
261  public static int indexOfCond(Instruction i) {
262    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
263    return 3;
264  }
265  /**
266   * Does the argument instruction have a non-null
267   * operand named Cond?
268   * @param i the instruction to access.
269   * @return <code>true</code> if the instruction has an non-null
270   *         operand named Cond or <code>false</code>
271   *         if it does not.
272   */
273  public static boolean hasCond(Instruction i) {
274    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
275    return i.getOperand(3) != null;
276  }
277
278  /**
279   * Get the operand called TrapCode from the
280   * argument instruction. Note that the returned operand
281   * will still point to its containing instruction.
282   * @param i the instruction to fetch the operand from
283   * @return the operand called TrapCode
284   */
285  public static TrapCodeOperand getTrapCode(Instruction i) {
286    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
287    return (TrapCodeOperand) i.getOperand(4);
288  }
289  /**
290   * Get the operand called TrapCode from the argument
291   * instruction clearing its instruction pointer. The returned
292   * operand will not point to any containing instruction.
293   * @param i the instruction to fetch the operand from
294   * @return the operand called TrapCode
295   */
296  public static TrapCodeOperand getClearTrapCode(Instruction i) {
297    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
298    return (TrapCodeOperand) i.getClearOperand(4);
299  }
300  /**
301   * Set the operand called TrapCode in the argument
302   * instruction to the argument operand. The operand will
303   * now point to the argument instruction as its containing
304   * instruction.
305   * @param i the instruction in which to store the operand
306   * @param TrapCode the operand to store
307   */
308  public static void setTrapCode(Instruction i, TrapCodeOperand TrapCode) {
309    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
310    i.putOperand(4, TrapCode);
311  }
312  /**
313   * Return the index of the operand called TrapCode
314   * in the argument instruction.
315   * @param i the instruction to access.
316   * @return the index of the operand called TrapCode
317   *         in the argument instruction
318   */
319  public static int indexOfTrapCode(Instruction i) {
320    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
321    return 4;
322  }
323  /**
324   * Does the argument instruction have a non-null
325   * operand named TrapCode?
326   * @param i the instruction to access.
327   * @return <code>true</code> if the instruction has an non-null
328   *         operand named TrapCode or <code>false</code>
329   *         if it does not.
330   */
331  public static boolean hasTrapCode(Instruction i) {
332    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_TrapIf");
333    return i.getOperand(4) != null;
334  }
335
336
337  /**
338   * Create an instruction of the MIR_TrapIf instruction format.
339   * @param o the instruction's operator
340   * @param GuardResult the instruction's GuardResult operand
341   * @param Val1 the instruction's Val1 operand
342   * @param Val2 the instruction's Val2 operand
343   * @param Cond the instruction's Cond operand
344   * @param TrapCode the instruction's TrapCode operand
345   * @return the newly created MIR_TrapIf instruction
346   */
347  public static Instruction create(Operator o
348                   , RegisterOperand GuardResult
349                   , Operand Val1
350                   , Operand Val2
351                   , IA32ConditionOperand Cond
352                   , TrapCodeOperand TrapCode
353                )
354  {
355    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_TrapIf");
356    Instruction i = Instruction.create(o, 5);
357    i.putOperand(0, GuardResult);
358    i.putOperand(1, Val1);
359    i.putOperand(2, Val2);
360    i.putOperand(3, Cond);
361    i.putOperand(4, TrapCode);
362    return i;
363  }
364
365  /**
366   * Mutate the argument instruction into an instruction of the
367   * MIR_TrapIf instruction format having the specified
368   * operator and operands.
369   * @param i the instruction to mutate
370   * @param o the instruction's operator
371   * @param GuardResult the instruction's GuardResult operand
372   * @param Val1 the instruction's Val1 operand
373   * @param Val2 the instruction's Val2 operand
374   * @param Cond the instruction's Cond operand
375   * @param TrapCode the instruction's TrapCode operand
376   * @return the mutated instruction
377   */
378  public static Instruction mutate(Instruction i, Operator o
379                   , RegisterOperand GuardResult
380                   , Operand Val1
381                   , Operand Val2
382                   , IA32ConditionOperand Cond
383                   , TrapCodeOperand TrapCode
384                )
385  {
386    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_TrapIf");
387    i.changeOperatorTo(o);
388    i.putOperand(0, GuardResult);
389    i.putOperand(1, Val1);
390    i.putOperand(2, Val2);
391    i.putOperand(3, Cond);
392    i.putOperand(4, TrapCode);
393    return i;
394  }
395}
396