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 CondMove 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 CondMove extends InstructionFormat {
022  /**
023   * InstructionFormat identification method for CondMove.
024   * @param i an instruction
025   * @return <code>true</code> if the InstructionFormat of the argument
026   *         instruction is CondMove 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 CondMove.
034   * @param o an instruction
035   * @return <code>true</code> if the InstructionFormat of the argument
036   *         operator is CondMove or <code>false</code>
037   *         if it is not.
038   */
039  public static boolean conforms(Operator o) {
040    return o.format == CondMove_format;
041  }
042
043  /**
044   * Get the operand called Result 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 Result
049   */
050  public static RegisterOperand getResult(Instruction i) {
051    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
052    return (RegisterOperand) i.getOperand(0);
053  }
054  /**
055   * Get the operand called Result 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 Result
060   */
061  public static RegisterOperand getClearResult(Instruction i) {
062    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
063    return (RegisterOperand) i.getClearOperand(0);
064  }
065  /**
066   * Set the operand called Result 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 Result the operand to store
072   */
073  public static void setResult(Instruction i, RegisterOperand Result) {
074    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
075    i.putOperand(0, Result);
076  }
077  /**
078   * Return the index of the operand called Result
079   * in the argument instruction.
080   * @param i the instruction to access.
081   * @return the index of the operand called Result
082   *         in the argument instruction
083   */
084  public static int indexOfResult(Instruction i) {
085    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
086    return 0;
087  }
088  /**
089   * Does the argument instruction have a non-null
090   * operand named Result?
091   * @param i the instruction to access.
092   * @return <code>true</code> if the instruction has an non-null
093   *         operand named Result or <code>false</code>
094   *         if it does not.
095   */
096  public static boolean hasResult(Instruction i) {
097    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
098    return i.getOperand(0) != null;
099  }
100
101  /**
102   * Get the operand called Val1 from the
103   * argument instruction. Note that the returned operand
104   * will still point to its containing instruction.
105   * @param i the instruction to fetch the operand from
106   * @return the operand called Val1
107   */
108  public static Operand getVal1(Instruction i) {
109    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
110    return (Operand) i.getOperand(1);
111  }
112  /**
113   * Get the operand called Val1 from the argument
114   * instruction clearing its instruction pointer. The returned
115   * operand will not point to any containing instruction.
116   * @param i the instruction to fetch the operand from
117   * @return the operand called Val1
118   */
119  public static Operand getClearVal1(Instruction i) {
120    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
121    return (Operand) i.getClearOperand(1);
122  }
123  /**
124   * Set the operand called Val1 in the argument
125   * instruction to the argument operand. The operand will
126   * now point to the argument instruction as its containing
127   * instruction.
128   * @param i the instruction in which to store the operand
129   * @param Val1 the operand to store
130   */
131  public static void setVal1(Instruction i, Operand Val1) {
132    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
133    i.putOperand(1, Val1);
134  }
135  /**
136   * Return the index of the operand called Val1
137   * in the argument instruction.
138   * @param i the instruction to access.
139   * @return the index of the operand called Val1
140   *         in the argument instruction
141   */
142  public static int indexOfVal1(Instruction i) {
143    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
144    return 1;
145  }
146  /**
147   * Does the argument instruction have a non-null
148   * operand named Val1?
149   * @param i the instruction to access.
150   * @return <code>true</code> if the instruction has an non-null
151   *         operand named Val1 or <code>false</code>
152   *         if it does not.
153   */
154  public static boolean hasVal1(Instruction i) {
155    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
156    return i.getOperand(1) != null;
157  }
158
159  /**
160   * Get the operand called Val2 from the
161   * argument instruction. Note that the returned operand
162   * will still point to its containing instruction.
163   * @param i the instruction to fetch the operand from
164   * @return the operand called Val2
165   */
166  public static Operand getVal2(Instruction i) {
167    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
168    return (Operand) i.getOperand(2);
169  }
170  /**
171   * Get the operand called Val2 from the argument
172   * instruction clearing its instruction pointer. The returned
173   * operand will not point to any containing instruction.
174   * @param i the instruction to fetch the operand from
175   * @return the operand called Val2
176   */
177  public static Operand getClearVal2(Instruction i) {
178    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
179    return (Operand) i.getClearOperand(2);
180  }
181  /**
182   * Set the operand called Val2 in the argument
183   * instruction to the argument operand. The operand will
184   * now point to the argument instruction as its containing
185   * instruction.
186   * @param i the instruction in which to store the operand
187   * @param Val2 the operand to store
188   */
189  public static void setVal2(Instruction i, Operand Val2) {
190    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
191    i.putOperand(2, Val2);
192  }
193  /**
194   * Return the index of the operand called Val2
195   * in the argument instruction.
196   * @param i the instruction to access.
197   * @return the index of the operand called Val2
198   *         in the argument instruction
199   */
200  public static int indexOfVal2(Instruction i) {
201    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
202    return 2;
203  }
204  /**
205   * Does the argument instruction have a non-null
206   * operand named Val2?
207   * @param i the instruction to access.
208   * @return <code>true</code> if the instruction has an non-null
209   *         operand named Val2 or <code>false</code>
210   *         if it does not.
211   */
212  public static boolean hasVal2(Instruction i) {
213    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
214    return i.getOperand(2) != null;
215  }
216
217  /**
218   * Get the operand called Cond from the
219   * argument instruction. Note that the returned operand
220   * will still point to its containing instruction.
221   * @param i the instruction to fetch the operand from
222   * @return the operand called Cond
223   */
224  public static ConditionOperand getCond(Instruction i) {
225    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
226    return (ConditionOperand) i.getOperand(3);
227  }
228  /**
229   * Get the operand called Cond from the argument
230   * instruction clearing its instruction pointer. The returned
231   * operand will not point to any containing instruction.
232   * @param i the instruction to fetch the operand from
233   * @return the operand called Cond
234   */
235  public static ConditionOperand getClearCond(Instruction i) {
236    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
237    return (ConditionOperand) i.getClearOperand(3);
238  }
239  /**
240   * Set the operand called Cond in the argument
241   * instruction to the argument operand. The operand will
242   * now point to the argument instruction as its containing
243   * instruction.
244   * @param i the instruction in which to store the operand
245   * @param Cond the operand to store
246   */
247  public static void setCond(Instruction i, ConditionOperand Cond) {
248    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
249    i.putOperand(3, Cond);
250  }
251  /**
252   * Return the index of the operand called Cond
253   * in the argument instruction.
254   * @param i the instruction to access.
255   * @return the index of the operand called Cond
256   *         in the argument instruction
257   */
258  public static int indexOfCond(Instruction i) {
259    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
260    return 3;
261  }
262  /**
263   * Does the argument instruction have a non-null
264   * operand named Cond?
265   * @param i the instruction to access.
266   * @return <code>true</code> if the instruction has an non-null
267   *         operand named Cond or <code>false</code>
268   *         if it does not.
269   */
270  public static boolean hasCond(Instruction i) {
271    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
272    return i.getOperand(3) != null;
273  }
274
275  /**
276   * Get the operand called TrueValue from the
277   * argument instruction. Note that the returned operand
278   * will still point to its containing instruction.
279   * @param i the instruction to fetch the operand from
280   * @return the operand called TrueValue
281   */
282  public static Operand getTrueValue(Instruction i) {
283    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
284    return (Operand) i.getOperand(4);
285  }
286  /**
287   * Get the operand called TrueValue from the argument
288   * instruction clearing its instruction pointer. The returned
289   * operand will not point to any containing instruction.
290   * @param i the instruction to fetch the operand from
291   * @return the operand called TrueValue
292   */
293  public static Operand getClearTrueValue(Instruction i) {
294    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
295    return (Operand) i.getClearOperand(4);
296  }
297  /**
298   * Set the operand called TrueValue in the argument
299   * instruction to the argument operand. The operand will
300   * now point to the argument instruction as its containing
301   * instruction.
302   * @param i the instruction in which to store the operand
303   * @param TrueValue the operand to store
304   */
305  public static void setTrueValue(Instruction i, Operand TrueValue) {
306    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
307    i.putOperand(4, TrueValue);
308  }
309  /**
310   * Return the index of the operand called TrueValue
311   * in the argument instruction.
312   * @param i the instruction to access.
313   * @return the index of the operand called TrueValue
314   *         in the argument instruction
315   */
316  public static int indexOfTrueValue(Instruction i) {
317    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
318    return 4;
319  }
320  /**
321   * Does the argument instruction have a non-null
322   * operand named TrueValue?
323   * @param i the instruction to access.
324   * @return <code>true</code> if the instruction has an non-null
325   *         operand named TrueValue or <code>false</code>
326   *         if it does not.
327   */
328  public static boolean hasTrueValue(Instruction i) {
329    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
330    return i.getOperand(4) != null;
331  }
332
333  /**
334   * Get the operand called FalseValue from the
335   * argument instruction. Note that the returned operand
336   * will still point to its containing instruction.
337   * @param i the instruction to fetch the operand from
338   * @return the operand called FalseValue
339   */
340  public static Operand getFalseValue(Instruction i) {
341    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
342    return (Operand) i.getOperand(5);
343  }
344  /**
345   * Get the operand called FalseValue from the argument
346   * instruction clearing its instruction pointer. The returned
347   * operand will not point to any containing instruction.
348   * @param i the instruction to fetch the operand from
349   * @return the operand called FalseValue
350   */
351  public static Operand getClearFalseValue(Instruction i) {
352    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
353    return (Operand) i.getClearOperand(5);
354  }
355  /**
356   * Set the operand called FalseValue in the argument
357   * instruction to the argument operand. The operand will
358   * now point to the argument instruction as its containing
359   * instruction.
360   * @param i the instruction in which to store the operand
361   * @param FalseValue the operand to store
362   */
363  public static void setFalseValue(Instruction i, Operand FalseValue) {
364    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
365    i.putOperand(5, FalseValue);
366  }
367  /**
368   * Return the index of the operand called FalseValue
369   * in the argument instruction.
370   * @param i the instruction to access.
371   * @return the index of the operand called FalseValue
372   *         in the argument instruction
373   */
374  public static int indexOfFalseValue(Instruction i) {
375    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
376    return 5;
377  }
378  /**
379   * Does the argument instruction have a non-null
380   * operand named FalseValue?
381   * @param i the instruction to access.
382   * @return <code>true</code> if the instruction has an non-null
383   *         operand named FalseValue or <code>false</code>
384   *         if it does not.
385   */
386  public static boolean hasFalseValue(Instruction i) {
387    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "CondMove");
388    return i.getOperand(5) != null;
389  }
390
391
392  /**
393   * Create an instruction of the CondMove instruction format.
394   * @param o the instruction's operator
395   * @param Result the instruction's Result operand
396   * @param Val1 the instruction's Val1 operand
397   * @param Val2 the instruction's Val2 operand
398   * @param Cond the instruction's Cond operand
399   * @param TrueValue the instruction's TrueValue operand
400   * @param FalseValue the instruction's FalseValue operand
401   * @return the newly created CondMove instruction
402   */
403  public static Instruction create(Operator o
404                   , RegisterOperand Result
405                   , Operand Val1
406                   , Operand Val2
407                   , ConditionOperand Cond
408                   , Operand TrueValue
409                   , Operand FalseValue
410                )
411  {
412    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "CondMove");
413    Instruction i = Instruction.create(o, 6);
414    i.putOperand(0, Result);
415    i.putOperand(1, Val1);
416    i.putOperand(2, Val2);
417    i.putOperand(3, Cond);
418    i.putOperand(4, TrueValue);
419    i.putOperand(5, FalseValue);
420    return i;
421  }
422
423  /**
424   * Mutate the argument instruction into an instruction of the
425   * CondMove instruction format having the specified
426   * operator and operands.
427   * @param i the instruction to mutate
428   * @param o the instruction's operator
429   * @param Result the instruction's Result operand
430   * @param Val1 the instruction's Val1 operand
431   * @param Val2 the instruction's Val2 operand
432   * @param Cond the instruction's Cond operand
433   * @param TrueValue the instruction's TrueValue operand
434   * @param FalseValue the instruction's FalseValue operand
435   * @return the mutated instruction
436   */
437  public static Instruction mutate(Instruction i, Operator o
438                   , RegisterOperand Result
439                   , Operand Val1
440                   , Operand Val2
441                   , ConditionOperand Cond
442                   , Operand TrueValue
443                   , Operand FalseValue
444                )
445  {
446    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "CondMove");
447    i.resizeNumberOfOperands(6);
448
449    i.changeOperatorTo(o);
450    i.putOperand(0, Result);
451    i.putOperand(1, Val1);
452    i.putOperand(2, Val2);
453    i.putOperand(3, Cond);
454    i.putOperand(4, TrueValue);
455    i.putOperand(5, FalseValue);
456    return i;
457  }
458}
459