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.ppc;
009
010import org.jikesrvm.Configuration;
011import org.jikesrvm.compilers.opt.ir.operand.ppc.PowerPCConditionOperand;
012import org.jikesrvm.compilers.opt.ir.operand.ppc.PowerPCTrapOperand;
013import org.jikesrvm.compilers.opt.ir.operand.*;
014import org.jikesrvm.compilers.opt.ir.Instruction;
015import org.jikesrvm.compilers.opt.ir.Operator;
016
017/**
018 * The MIR_CondCall InstructionFormat class.
019 *
020 * The header comment for {@link Instruction} contains
021 * an explanation of the role of InstructionFormats in the
022 * opt compiler's IR.
023 */
024@SuppressWarnings("unused")  // Machine generated code is never 100% clean
025public final class MIR_CondCall extends ArchInstructionFormat {
026  /**
027   * InstructionFormat identification method for MIR_CondCall.
028   * @param i an instruction
029   * @return <code>true</code> if the InstructionFormat of the argument
030   *         instruction is MIR_CondCall or <code>false</code>
031   *         if it is not.
032   */
033  public static boolean conforms(Instruction i) {
034    return conforms(i.operator());
035  }
036  /**
037   * InstructionFormat identification method for MIR_CondCall.
038   * @param o an instruction
039   * @return <code>true</code> if the InstructionFormat of the argument
040   *         operator is MIR_CondCall or <code>false</code>
041   *         if it is not.
042   */
043  public static boolean conforms(Operator o) {
044    return o.format == MIR_CondCall_format;
045  }
046
047  /**
048   * Get the operand called Result from the
049   * argument instruction. Note that the returned operand
050   * will still point to its containing instruction.
051   * @param i the instruction to fetch the operand from
052   * @return the operand called Result
053   */
054  public static RegisterOperand getResult(Instruction i) {
055    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
056    return (RegisterOperand) i.getOperand(0);
057  }
058  /**
059   * Get the operand called Result from the argument
060   * instruction clearing its instruction pointer. The returned
061   * operand will not point to any containing instruction.
062   * @param i the instruction to fetch the operand from
063   * @return the operand called Result
064   */
065  public static RegisterOperand getClearResult(Instruction i) {
066    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
067    return (RegisterOperand) i.getClearOperand(0);
068  }
069  /**
070   * Set the operand called Result in the argument
071   * instruction to the argument operand. The operand will
072   * now point to the argument instruction as its containing
073   * instruction.
074   * @param i the instruction in which to store the operand
075   * @param Result the operand to store
076   */
077  public static void setResult(Instruction i, RegisterOperand Result) {
078    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
079    i.putOperand(0, Result);
080  }
081  /**
082   * Return the index of the operand called Result
083   * in the argument instruction.
084   * @param i the instruction to access.
085   * @return the index of the operand called Result
086   *         in the argument instruction
087   */
088  public static int indexOfResult(Instruction i) {
089    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
090    return 0;
091  }
092  /**
093   * Does the argument instruction have a non-null
094   * operand named Result?
095   * @param i the instruction to access.
096   * @return <code>true</code> if the instruction has an non-null
097   *         operand named Result or <code>false</code>
098   *         if it does not.
099   */
100  public static boolean hasResult(Instruction i) {
101    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
102    return i.getOperand(0) != null;
103  }
104
105  /**
106   * Get the operand called Result2 from the
107   * argument instruction. Note that the returned operand
108   * will still point to its containing instruction.
109   * @param i the instruction to fetch the operand from
110   * @return the operand called Result2
111   */
112  public static RegisterOperand getResult2(Instruction i) {
113    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
114    return (RegisterOperand) i.getOperand(1);
115  }
116  /**
117   * Get the operand called Result2 from the argument
118   * instruction clearing its instruction pointer. The returned
119   * operand will not point to any containing instruction.
120   * @param i the instruction to fetch the operand from
121   * @return the operand called Result2
122   */
123  public static RegisterOperand getClearResult2(Instruction i) {
124    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
125    return (RegisterOperand) i.getClearOperand(1);
126  }
127  /**
128   * Set the operand called Result2 in the argument
129   * instruction to the argument operand. The operand will
130   * now point to the argument instruction as its containing
131   * instruction.
132   * @param i the instruction in which to store the operand
133   * @param Result2 the operand to store
134   */
135  public static void setResult2(Instruction i, RegisterOperand Result2) {
136    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
137    i.putOperand(1, Result2);
138  }
139  /**
140   * Return the index of the operand called Result2
141   * in the argument instruction.
142   * @param i the instruction to access.
143   * @return the index of the operand called Result2
144   *         in the argument instruction
145   */
146  public static int indexOfResult2(Instruction i) {
147    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
148    return 1;
149  }
150  /**
151   * Does the argument instruction have a non-null
152   * operand named Result2?
153   * @param i the instruction to access.
154   * @return <code>true</code> if the instruction has an non-null
155   *         operand named Result2 or <code>false</code>
156   *         if it does not.
157   */
158  public static boolean hasResult2(Instruction i) {
159    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
160    return i.getOperand(1) != null;
161  }
162
163  /**
164   * Get the operand called Value from the
165   * argument instruction. Note that the returned operand
166   * will still point to its containing instruction.
167   * @param i the instruction to fetch the operand from
168   * @return the operand called Value
169   */
170  public static RegisterOperand getValue(Instruction i) {
171    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
172    return (RegisterOperand) i.getOperand(2);
173  }
174  /**
175   * Get the operand called Value from the argument
176   * instruction clearing its instruction pointer. The returned
177   * operand will not point to any containing instruction.
178   * @param i the instruction to fetch the operand from
179   * @return the operand called Value
180   */
181  public static RegisterOperand getClearValue(Instruction i) {
182    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
183    return (RegisterOperand) i.getClearOperand(2);
184  }
185  /**
186   * Set the operand called Value in the argument
187   * instruction to the argument operand. The operand will
188   * now point to the argument instruction as its containing
189   * instruction.
190   * @param i the instruction in which to store the operand
191   * @param Value the operand to store
192   */
193  public static void setValue(Instruction i, RegisterOperand Value) {
194    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
195    i.putOperand(2, Value);
196  }
197  /**
198   * Return the index of the operand called Value
199   * in the argument instruction.
200   * @param i the instruction to access.
201   * @return the index of the operand called Value
202   *         in the argument instruction
203   */
204  public static int indexOfValue(Instruction i) {
205    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
206    return 2;
207  }
208  /**
209   * Does the argument instruction have a non-null
210   * operand named Value?
211   * @param i the instruction to access.
212   * @return <code>true</code> if the instruction has an non-null
213   *         operand named Value or <code>false</code>
214   *         if it does not.
215   */
216  public static boolean hasValue(Instruction i) {
217    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
218    return i.getOperand(2) != null;
219  }
220
221  /**
222   * Get the operand called Cond from the
223   * argument instruction. Note that the returned operand
224   * will still point to its containing instruction.
225   * @param i the instruction to fetch the operand from
226   * @return the operand called Cond
227   */
228  public static PowerPCConditionOperand getCond(Instruction i) {
229    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
230    return (PowerPCConditionOperand) i.getOperand(3);
231  }
232  /**
233   * Get the operand called Cond from the argument
234   * instruction clearing its instruction pointer. The returned
235   * operand will not point to any containing instruction.
236   * @param i the instruction to fetch the operand from
237   * @return the operand called Cond
238   */
239  public static PowerPCConditionOperand getClearCond(Instruction i) {
240    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
241    return (PowerPCConditionOperand) i.getClearOperand(3);
242  }
243  /**
244   * Set the operand called Cond in the argument
245   * instruction to the argument operand. The operand will
246   * now point to the argument instruction as its containing
247   * instruction.
248   * @param i the instruction in which to store the operand
249   * @param Cond the operand to store
250   */
251  public static void setCond(Instruction i, PowerPCConditionOperand Cond) {
252    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
253    i.putOperand(3, Cond);
254  }
255  /**
256   * Return the index of the operand called Cond
257   * in the argument instruction.
258   * @param i the instruction to access.
259   * @return the index of the operand called Cond
260   *         in the argument instruction
261   */
262  public static int indexOfCond(Instruction i) {
263    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
264    return 3;
265  }
266  /**
267   * Does the argument instruction have a non-null
268   * operand named Cond?
269   * @param i the instruction to access.
270   * @return <code>true</code> if the instruction has an non-null
271   *         operand named Cond or <code>false</code>
272   *         if it does not.
273   */
274  public static boolean hasCond(Instruction i) {
275    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
276    return i.getOperand(3) != null;
277  }
278
279  /**
280   * Get the operand called Target from the
281   * argument instruction. Note that the returned operand
282   * will still point to its containing instruction.
283   * @param i the instruction to fetch the operand from
284   * @return the operand called Target
285   */
286  public static BranchOperand getTarget(Instruction i) {
287    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
288    return (BranchOperand) i.getOperand(4);
289  }
290  /**
291   * Get the operand called Target from the argument
292   * instruction clearing its instruction pointer. The returned
293   * operand will not point to any containing instruction.
294   * @param i the instruction to fetch the operand from
295   * @return the operand called Target
296   */
297  public static BranchOperand getClearTarget(Instruction i) {
298    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
299    return (BranchOperand) i.getClearOperand(4);
300  }
301  /**
302   * Set the operand called Target in the argument
303   * instruction to the argument operand. The operand will
304   * now point to the argument instruction as its containing
305   * instruction.
306   * @param i the instruction in which to store the operand
307   * @param Target the operand to store
308   */
309  public static void setTarget(Instruction i, BranchOperand Target) {
310    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
311    i.putOperand(4, Target);
312  }
313  /**
314   * Return the index of the operand called Target
315   * in the argument instruction.
316   * @param i the instruction to access.
317   * @return the index of the operand called Target
318   *         in the argument instruction
319   */
320  public static int indexOfTarget(Instruction i) {
321    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
322    return 4;
323  }
324  /**
325   * Does the argument instruction have a non-null
326   * operand named Target?
327   * @param i the instruction to access.
328   * @return <code>true</code> if the instruction has an non-null
329   *         operand named Target or <code>false</code>
330   *         if it does not.
331   */
332  public static boolean hasTarget(Instruction i) {
333    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
334    return i.getOperand(4) != null;
335  }
336
337  /**
338   * Get the k'th operand called Param from the
339   * argument instruction. Note that the returned operand
340   * will still point to its containing instruction.
341   * @param i the instruction to fetch the operand from
342   * @param k the index of the operand
343   * @return the k'th operand called Param
344   */
345  public static Operand getParam(Instruction i, int k) {
346    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
347    return (Operand) i.getOperand(5+k);
348  }
349  /**
350   * Get the k'th operand called Param from the argument
351   * instruction clearing its instruction pointer. The returned
352   * operand will not point to any containing instruction.
353   * @param i the instruction to fetch the operand from
354   * @param k the index of the operand
355   * @return the k'th operand called Param
356   */
357  public static Operand getClearParam(Instruction i, int k) {
358    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
359    return (Operand) i.getClearOperand(5+k);
360  }
361  /**
362   * Set the k'th operand called Param in the argument
363   * instruction to the argument operand. The operand will
364   * now point to the argument instruction as its containing
365   * instruction.
366   * @param i the instruction in which to store the operand
367   * @param k the index of the operand
368   * @param o the operand to store
369   */
370  public static void setParam(Instruction i, int k, Operand o) {
371    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
372    i.putOperand(5+k, o);
373  }
374  /**
375   * Return the index of the k'th operand called Param
376   * in the argument instruction.
377   * @param i the instruction to access.
378   * @param k the index of the operand.
379   * @return the index of the k'th operand called Param
380   *         in the argument instruction
381   */
382  public static int indexOfParam(Instruction i, int k) {
383    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
384    return 5+k;
385  }
386  /**
387   * Does the argument instruction have a non-null
388   * k'th operand named Param?
389   * @param i the instruction to access.
390   * @param k the index of the operand.
391   * @return <code>true</code> if the instruction has an non-null
392   *         k'th operand named Param or <code>false</code>
393   *         if it does not.
394   */
395  public static boolean hasParam(Instruction i, int k) {
396    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
397    return i.getOperand(5+k) != null;
398  }
399
400  /**
401   * Return the index of the first operand called Param
402   * in the argument instruction.
403   * @param i the instruction to access.
404   * @return the index of the first operand called Param
405   *         in the argument instruction
406   */
407  public static int indexOfParams(Instruction i)
408  {
409    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
410    return 5;
411  }
412  /**
413   * Does the argument instruction have any operands
414   * named Param?
415   * @param i the instruction to access.
416   * @return <code>true</code> if the instruction has operands
417   *         named Param or <code>false</code> if it does not.
418   */
419  public static boolean hasParams(Instruction i)
420  {
421    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
422    return i.getNumberOfOperands()-5 > 0 && i.getOperand(5) != null;
423  }
424
425  /**
426   * How many variable-length operands called Params
427   * does the argument instruction have?
428   * @param i the instruction to access
429   * @return the number of operands called Params the instruction has
430   */
431  public static int getNumberOfParams(Instruction i)
432  {
433    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
434    return i.getNumberOfOperands()-5;
435  }
436
437  /**
438   * Change the number of Params that may be stored in
439   * the argument instruction to numVarOps.
440   * @param i the instruction to access
441   * @param numVarOps the new number of variable operands called Params
442   *        that may be stored in the instruction
443   */
444  public static void resizeNumberOfParams(Instruction i, int numVarOps)
445  {
446    if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondCall");
447  if (5+numVarOps>MIN_OPERAND_ARRAY_LENGTH)
448    i.resizeNumberOfOperands(5+numVarOps);
449  else
450    for (int j = 5+numVarOps; j < MIN_OPERAND_ARRAY_LENGTH; j++)
451      i.putOperand(j, null);
452  }
453
454  /**
455   * Create an instruction of the MIR_CondCall instruction format.
456   * @param o the instruction's operator
457   * @param Result the instruction's Result operand
458   * @param Result2 the instruction's Result2 operand
459   * @param Value the instruction's Value operand
460   * @param Cond the instruction's Cond operand
461   * @param Target the instruction's Target operand
462   * @param numVarOps the number of variable length operands that
463   *                 will be stored in the insruction.
464   * @return the newly created MIR_CondCall instruction
465   */
466  public static Instruction create(Operator o
467                   , RegisterOperand Result
468                   , RegisterOperand Result2
469                   , RegisterOperand Value
470                   , PowerPCConditionOperand Cond
471                   , BranchOperand Target
472                   , int numVarOps
473                )
474  {
475    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondCall");
476    Instruction i = Instruction.create(o, Math.max(5+numVarOps, MIN_OPERAND_ARRAY_LENGTH));
477    i.putOperand(0, Result);
478    i.putOperand(1, Result2);
479    i.putOperand(2, Value);
480    i.putOperand(3, Cond);
481    i.putOperand(4, Target);
482    return i;
483  }
484  /**
485   * Create an instruction of the MIR_CondCall instruction format
486   * with 0 variable arguments.
487   * @param o the instruction's operator
488   * @param Result the instruction's Result operand
489   * @param Result2 the instruction's Result2 operand
490   * @param Value the instruction's Value operand
491   * @param Cond the instruction's Cond operand
492   * @param Target the instruction's Target operand
493   * @return the newly created MIR_CondCall instruction
494   */
495  public static Instruction create0(Operator o
496                   , RegisterOperand Result
497                   , RegisterOperand Result2
498                   , RegisterOperand Value
499                   , PowerPCConditionOperand Cond
500                   , BranchOperand Target
501                )
502  {
503    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondCall");
504    Instruction i = Instruction.create(o, 5);
505    i.putOperand(0, Result);
506    i.putOperand(1, Result2);
507    i.putOperand(2, Value);
508    i.putOperand(3, Cond);
509    i.putOperand(4, Target);
510    return i;
511  }
512
513  /**
514   * Mutate the argument instruction into an instruction of the
515   * MIR_CondCall instruction format having the specified
516   * operator and operands.
517   * @param i the instruction to mutate
518   * @param o the instruction's operator
519   * @param Result the instruction's Result operand
520   * @param Result2 the instruction's Result2 operand
521   * @param Value the instruction's Value operand
522   * @param Cond the instruction's Cond operand
523   * @param Target the instruction's Target operand
524   * @param numVarOps the number of variable length operands that
525   *                  will be stored in the insruction.
526   * @return the mutated instruction
527   */
528  public static Instruction mutate(Instruction i, Operator o
529                   , RegisterOperand Result
530                   , RegisterOperand Result2
531                   , RegisterOperand Value
532                   , PowerPCConditionOperand Cond
533                   , BranchOperand Target
534                   , int numVarOps
535                )
536  {
537    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondCall");
538    if (5+numVarOps>MIN_OPERAND_ARRAY_LENGTH)
539      i.resizeNumberOfOperands(5+numVarOps);
540
541    i.changeOperatorTo(o);
542    i.putOperand(0, Result);
543    i.putOperand(1, Result2);
544    i.putOperand(2, Value);
545    i.putOperand(3, Cond);
546    i.putOperand(4, Target);
547    return i;
548  }
549  /**
550   * Mutate the argument instruction into an instruction of the
551   * MIR_CondCall instruction format having the specified
552   * operator, operands, and number of variable-length operands.
553   * @param i the instruction to mutate
554   * @param o the instruction's operator
555   * @param Result the instruction's Result operand
556   * @param Result2 the instruction's Result2 operand
557   * @param Value the instruction's Value operand
558   * @param Cond the instruction's Cond operand
559   * @param Target the instruction's Target operand
560   * @return the mutated instruction
561   */
562  public static Instruction mutate0(Instruction i, Operator o
563                   , RegisterOperand Result
564                   , RegisterOperand Result2
565                   , RegisterOperand Value
566                   , PowerPCConditionOperand Cond
567                   , BranchOperand Target
568                )
569  {
570    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondCall");
571    i.changeOperatorTo(o);
572    i.putOperand(0, Result);
573    i.putOperand(1, Result2);
574    i.putOperand(2, Value);
575    i.putOperand(3, Cond);
576    i.putOperand(4, Target);
577    return i;
578  }
579  /**
580   * Create an instruction of the MIR_CondCall instruction format.
581   * @param o the instruction's operator
582   * @param Result the instruction's Result operand
583   * @param Result2 the instruction's Result2 operand
584   * @param Value the instruction's Value operand
585   * @param Cond the instruction's Cond operand
586   * @param numVarOps the number of variable length operands that
587   *                 will be stored in the insruction.
588   * @return the newly created MIR_CondCall instruction
589   */
590  public static Instruction create(Operator o
591                   , RegisterOperand Result
592                   , RegisterOperand Result2
593                   , RegisterOperand Value
594                   , PowerPCConditionOperand Cond
595                   , int numVarOps
596                )
597  {
598    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondCall");
599    Instruction i = Instruction.create(o, Math.max(5+numVarOps, MIN_OPERAND_ARRAY_LENGTH));
600    i.putOperand(0, Result);
601    i.putOperand(1, Result2);
602    i.putOperand(2, Value);
603    i.putOperand(3, Cond);
604    return i;
605  }
606  /**
607   * Create an instruction of the MIR_CondCall instruction format
608   * with 0 variable arguments.
609   * @param o the instruction's operator
610   * @param Result the instruction's Result operand
611   * @param Result2 the instruction's Result2 operand
612   * @param Value the instruction's Value operand
613   * @param Cond the instruction's Cond operand
614   * @return the newly created MIR_CondCall instruction
615   */
616  public static Instruction create0(Operator o
617                   , RegisterOperand Result
618                   , RegisterOperand Result2
619                   , RegisterOperand Value
620                   , PowerPCConditionOperand Cond
621                )
622  {
623    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondCall");
624    Instruction i = Instruction.create(o, 5);
625    i.putOperand(0, Result);
626    i.putOperand(1, Result2);
627    i.putOperand(2, Value);
628    i.putOperand(3, Cond);
629    return i;
630  }
631
632  /**
633   * Mutate the argument instruction into an instruction of the
634   * MIR_CondCall instruction format having the specified
635   * operator and operands.
636   * @param i the instruction to mutate
637   * @param o the instruction's operator
638   * @param Result the instruction's Result operand
639   * @param Result2 the instruction's Result2 operand
640   * @param Value the instruction's Value operand
641   * @param Cond the instruction's Cond operand
642   * @param numVarOps the number of variable length operands that
643   *                  will be stored in the insruction.
644   * @return the mutated instruction
645   */
646  public static Instruction mutate(Instruction i, Operator o
647                   , RegisterOperand Result
648                   , RegisterOperand Result2
649                   , RegisterOperand Value
650                   , PowerPCConditionOperand Cond
651                   , int numVarOps
652                )
653  {
654    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondCall");
655    if (5+numVarOps>MIN_OPERAND_ARRAY_LENGTH)
656      i.resizeNumberOfOperands(5+numVarOps);
657
658    i.changeOperatorTo(o);
659    i.putOperand(0, Result);
660    i.putOperand(1, Result2);
661    i.putOperand(2, Value);
662    i.putOperand(3, Cond);
663    i.putOperand(4, null);
664    return i;
665  }
666  /**
667   * Mutate the argument instruction into an instruction of the
668   * MIR_CondCall instruction format having the specified
669   * operator, operands, and number of variable-length operands.
670   * @param i the instruction to mutate
671   * @param o the instruction's operator
672   * @param Result the instruction's Result operand
673   * @param Result2 the instruction's Result2 operand
674   * @param Value the instruction's Value operand
675   * @param Cond the instruction's Cond operand
676   * @return the mutated instruction
677   */
678  public static Instruction mutate0(Instruction i, Operator o
679                   , RegisterOperand Result
680                   , RegisterOperand Result2
681                   , RegisterOperand Value
682                   , PowerPCConditionOperand Cond
683                )
684  {
685    if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondCall");
686    i.changeOperatorTo(o);
687    i.putOperand(0, Result);
688    i.putOperand(1, Result2);
689    i.putOperand(2, Value);
690    i.putOperand(3, Cond);
691    i.putOperand(4, null);
692    return i;
693  }
694}
695