001
002 /*
003 * THIS FILE IS MACHINE_GENERATED. DO NOT EDIT.
004 * See InstructionFormats.template, InstructionFormatList.dat,
005 * OperatorList.dat, etc.
006 */
007
008 package org.jikesrvm.compilers.opt.ir;
009
010 import org.jikesrvm.Configuration;
011 import org.jikesrvm.compilers.opt.ir.operand.ia32.IA32ConditionOperand; //NOPMD
012 import org.jikesrvm.compilers.opt.ir.operand.*;
013
014 /**
015 * The MIR_CondBranch2 InstructionFormat class.
016 *
017 * The header comment for {@link Instruction} contains
018 * an explanation of the role of InstructionFormats in the
019 * opt compiler's IR.
020 */
021 @SuppressWarnings("unused") // Machine generated code is never 100% clean
022 public final class MIR_CondBranch2 extends InstructionFormat {
023 /**
024 * InstructionFormat identification method for MIR_CondBranch2.
025 * @param i an instruction
026 * @return <code>true</code> if the InstructionFormat of the argument
027 * instruction is MIR_CondBranch2 or <code>false</code>
028 * if it is not.
029 */
030 public static boolean conforms(Instruction i) {
031 return conforms(i.operator);
032 }
033 /**
034 * InstructionFormat identification method for MIR_CondBranch2.
035 * @param o an instruction
036 * @return <code>true</code> if the InstructionFormat of the argument
037 * operator is MIR_CondBranch2 or <code>false</code>
038 * if it is not.
039 */
040 public static boolean conforms(Operator o) {
041 return o.format == MIR_CondBranch2_format;
042 }
043
044 /**
045 * Get the operand called Cond1 from the
046 * argument instruction. Note that the returned operand
047 * will still point to its containing instruction.
048 * @param i the instruction to fetch the operand from
049 * @return the operand called Cond1
050 */
051 public static IA32ConditionOperand getCond1(Instruction i) {
052 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
053 return (IA32ConditionOperand) i.getOperand(0);
054 }
055 /**
056 * Get the operand called Cond1 from the argument
057 * instruction clearing its instruction pointer. The returned
058 * operand will not point to any containing instruction.
059 * @param i the instruction to fetch the operand from
060 * @return the operand called Cond1
061 */
062 public static IA32ConditionOperand getClearCond1(Instruction i) {
063 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
064 return (IA32ConditionOperand) i.getClearOperand(0);
065 }
066 /**
067 * Set the operand called Cond1 in the argument
068 * instruction to the argument operand. The operand will
069 * now point to the argument instruction as its containing
070 * instruction.
071 * @param i the instruction in which to store the operand
072 * @param Cond1 the operand to store
073 */
074 public static void setCond1(Instruction i, IA32ConditionOperand Cond1) {
075 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
076 i.putOperand(0, Cond1);
077 }
078 /**
079 * Return the index of the operand called Cond1
080 * in the argument instruction.
081 * @param i the instruction to access.
082 * @return the index of the operand called Cond1
083 * in the argument instruction
084 */
085 public static int indexOfCond1(Instruction i) {
086 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
087 return 0;
088 }
089 /**
090 * Does the argument instruction have a non-null
091 * operand named Cond1?
092 * @param i the instruction to access.
093 * @return <code>true</code> if the instruction has an non-null
094 * operand named Cond1 or <code>false</code>
095 * if it does not.
096 */
097 public static boolean hasCond1(Instruction i) {
098 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
099 return i.getOperand(0) != null;
100 }
101
102 /**
103 * Get the operand called Target1 from the
104 * argument instruction. Note that the returned operand
105 * will still point to its containing instruction.
106 * @param i the instruction to fetch the operand from
107 * @return the operand called Target1
108 */
109 public static BranchOperand getTarget1(Instruction i) {
110 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
111 return (BranchOperand) i.getOperand(1);
112 }
113 /**
114 * Get the operand called Target1 from the argument
115 * instruction clearing its instruction pointer. The returned
116 * operand will not point to any containing instruction.
117 * @param i the instruction to fetch the operand from
118 * @return the operand called Target1
119 */
120 public static BranchOperand getClearTarget1(Instruction i) {
121 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
122 return (BranchOperand) i.getClearOperand(1);
123 }
124 /**
125 * Set the operand called Target1 in the argument
126 * instruction to the argument operand. The operand will
127 * now point to the argument instruction as its containing
128 * instruction.
129 * @param i the instruction in which to store the operand
130 * @param Target1 the operand to store
131 */
132 public static void setTarget1(Instruction i, BranchOperand Target1) {
133 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
134 i.putOperand(1, Target1);
135 }
136 /**
137 * Return the index of the operand called Target1
138 * in the argument instruction.
139 * @param i the instruction to access.
140 * @return the index of the operand called Target1
141 * in the argument instruction
142 */
143 public static int indexOfTarget1(Instruction i) {
144 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
145 return 1;
146 }
147 /**
148 * Does the argument instruction have a non-null
149 * operand named Target1?
150 * @param i the instruction to access.
151 * @return <code>true</code> if the instruction has an non-null
152 * operand named Target1 or <code>false</code>
153 * if it does not.
154 */
155 public static boolean hasTarget1(Instruction i) {
156 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
157 return i.getOperand(1) != null;
158 }
159
160 /**
161 * Get the operand called BranchProfile1 from the
162 * argument instruction. Note that the returned operand
163 * will still point to its containing instruction.
164 * @param i the instruction to fetch the operand from
165 * @return the operand called BranchProfile1
166 */
167 public static BranchProfileOperand getBranchProfile1(Instruction i) {
168 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
169 return (BranchProfileOperand) i.getOperand(2);
170 }
171 /**
172 * Get the operand called BranchProfile1 from the argument
173 * instruction clearing its instruction pointer. The returned
174 * operand will not point to any containing instruction.
175 * @param i the instruction to fetch the operand from
176 * @return the operand called BranchProfile1
177 */
178 public static BranchProfileOperand getClearBranchProfile1(Instruction i) {
179 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
180 return (BranchProfileOperand) i.getClearOperand(2);
181 }
182 /**
183 * Set the operand called BranchProfile1 in the argument
184 * instruction to the argument operand. The operand will
185 * now point to the argument instruction as its containing
186 * instruction.
187 * @param i the instruction in which to store the operand
188 * @param BranchProfile1 the operand to store
189 */
190 public static void setBranchProfile1(Instruction i, BranchProfileOperand BranchProfile1) {
191 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
192 i.putOperand(2, BranchProfile1);
193 }
194 /**
195 * Return the index of the operand called BranchProfile1
196 * in the argument instruction.
197 * @param i the instruction to access.
198 * @return the index of the operand called BranchProfile1
199 * in the argument instruction
200 */
201 public static int indexOfBranchProfile1(Instruction i) {
202 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
203 return 2;
204 }
205 /**
206 * Does the argument instruction have a non-null
207 * operand named BranchProfile1?
208 * @param i the instruction to access.
209 * @return <code>true</code> if the instruction has an non-null
210 * operand named BranchProfile1 or <code>false</code>
211 * if it does not.
212 */
213 public static boolean hasBranchProfile1(Instruction i) {
214 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
215 return i.getOperand(2) != null;
216 }
217
218 /**
219 * Get the operand called Cond2 from the
220 * argument instruction. Note that the returned operand
221 * will still point to its containing instruction.
222 * @param i the instruction to fetch the operand from
223 * @return the operand called Cond2
224 */
225 public static IA32ConditionOperand getCond2(Instruction i) {
226 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
227 return (IA32ConditionOperand) i.getOperand(3);
228 }
229 /**
230 * Get the operand called Cond2 from the argument
231 * instruction clearing its instruction pointer. The returned
232 * operand will not point to any containing instruction.
233 * @param i the instruction to fetch the operand from
234 * @return the operand called Cond2
235 */
236 public static IA32ConditionOperand getClearCond2(Instruction i) {
237 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
238 return (IA32ConditionOperand) i.getClearOperand(3);
239 }
240 /**
241 * Set the operand called Cond2 in the argument
242 * instruction to the argument operand. The operand will
243 * now point to the argument instruction as its containing
244 * instruction.
245 * @param i the instruction in which to store the operand
246 * @param Cond2 the operand to store
247 */
248 public static void setCond2(Instruction i, IA32ConditionOperand Cond2) {
249 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
250 i.putOperand(3, Cond2);
251 }
252 /**
253 * Return the index of the operand called Cond2
254 * in the argument instruction.
255 * @param i the instruction to access.
256 * @return the index of the operand called Cond2
257 * in the argument instruction
258 */
259 public static int indexOfCond2(Instruction i) {
260 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
261 return 3;
262 }
263 /**
264 * Does the argument instruction have a non-null
265 * operand named Cond2?
266 * @param i the instruction to access.
267 * @return <code>true</code> if the instruction has an non-null
268 * operand named Cond2 or <code>false</code>
269 * if it does not.
270 */
271 public static boolean hasCond2(Instruction i) {
272 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
273 return i.getOperand(3) != null;
274 }
275
276 /**
277 * Get the operand called Target2 from the
278 * argument instruction. Note that the returned operand
279 * will still point to its containing instruction.
280 * @param i the instruction to fetch the operand from
281 * @return the operand called Target2
282 */
283 public static BranchOperand getTarget2(Instruction i) {
284 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
285 return (BranchOperand) i.getOperand(4);
286 }
287 /**
288 * Get the operand called Target2 from the argument
289 * instruction clearing its instruction pointer. The returned
290 * operand will not point to any containing instruction.
291 * @param i the instruction to fetch the operand from
292 * @return the operand called Target2
293 */
294 public static BranchOperand getClearTarget2(Instruction i) {
295 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
296 return (BranchOperand) i.getClearOperand(4);
297 }
298 /**
299 * Set the operand called Target2 in the argument
300 * instruction to the argument operand. The operand will
301 * now point to the argument instruction as its containing
302 * instruction.
303 * @param i the instruction in which to store the operand
304 * @param Target2 the operand to store
305 */
306 public static void setTarget2(Instruction i, BranchOperand Target2) {
307 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
308 i.putOperand(4, Target2);
309 }
310 /**
311 * Return the index of the operand called Target2
312 * in the argument instruction.
313 * @param i the instruction to access.
314 * @return the index of the operand called Target2
315 * in the argument instruction
316 */
317 public static int indexOfTarget2(Instruction i) {
318 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
319 return 4;
320 }
321 /**
322 * Does the argument instruction have a non-null
323 * operand named Target2?
324 * @param i the instruction to access.
325 * @return <code>true</code> if the instruction has an non-null
326 * operand named Target2 or <code>false</code>
327 * if it does not.
328 */
329 public static boolean hasTarget2(Instruction i) {
330 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
331 return i.getOperand(4) != null;
332 }
333
334 /**
335 * Get the operand called BranchProfile2 from the
336 * argument instruction. Note that the returned operand
337 * will still point to its containing instruction.
338 * @param i the instruction to fetch the operand from
339 * @return the operand called BranchProfile2
340 */
341 public static BranchProfileOperand getBranchProfile2(Instruction i) {
342 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
343 return (BranchProfileOperand) i.getOperand(5);
344 }
345 /**
346 * Get the operand called BranchProfile2 from the argument
347 * instruction clearing its instruction pointer. The returned
348 * operand will not point to any containing instruction.
349 * @param i the instruction to fetch the operand from
350 * @return the operand called BranchProfile2
351 */
352 public static BranchProfileOperand getClearBranchProfile2(Instruction i) {
353 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
354 return (BranchProfileOperand) i.getClearOperand(5);
355 }
356 /**
357 * Set the operand called BranchProfile2 in the argument
358 * instruction to the argument operand. The operand will
359 * now point to the argument instruction as its containing
360 * instruction.
361 * @param i the instruction in which to store the operand
362 * @param BranchProfile2 the operand to store
363 */
364 public static void setBranchProfile2(Instruction i, BranchProfileOperand BranchProfile2) {
365 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
366 i.putOperand(5, BranchProfile2);
367 }
368 /**
369 * Return the index of the operand called BranchProfile2
370 * in the argument instruction.
371 * @param i the instruction to access.
372 * @return the index of the operand called BranchProfile2
373 * in the argument instruction
374 */
375 public static int indexOfBranchProfile2(Instruction i) {
376 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
377 return 5;
378 }
379 /**
380 * Does the argument instruction have a non-null
381 * operand named BranchProfile2?
382 * @param i the instruction to access.
383 * @return <code>true</code> if the instruction has an non-null
384 * operand named BranchProfile2 or <code>false</code>
385 * if it does not.
386 */
387 public static boolean hasBranchProfile2(Instruction i) {
388 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "MIR_CondBranch2");
389 return i.getOperand(5) != null;
390 }
391
392
393 /**
394 * Create an instruction of the MIR_CondBranch2 instruction format.
395 * @param o the instruction's operator
396 * @param Cond1 the instruction's Cond1 operand
397 * @param Target1 the instruction's Target1 operand
398 * @param BranchProfile1 the instruction's BranchProfile1 operand
399 * @param Cond2 the instruction's Cond2 operand
400 * @param Target2 the instruction's Target2 operand
401 * @param BranchProfile2 the instruction's BranchProfile2 operand
402 * @return the newly created MIR_CondBranch2 instruction
403 */
404 public static Instruction create(Operator o
405 , IA32ConditionOperand Cond1
406 , BranchOperand Target1
407 , BranchProfileOperand BranchProfile1
408 , IA32ConditionOperand Cond2
409 , BranchOperand Target2
410 , BranchProfileOperand BranchProfile2
411 )
412 {
413 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondBranch2");
414 Instruction i = new Instruction(o, 6);
415 i.putOperand(0, Cond1);
416 i.putOperand(1, Target1);
417 i.putOperand(2, BranchProfile1);
418 i.putOperand(3, Cond2);
419 i.putOperand(4, Target2);
420 i.putOperand(5, BranchProfile2);
421 return i;
422 }
423
424 /**
425 * Mutate the argument instruction into an instruction of the
426 * MIR_CondBranch2 instruction format having the specified
427 * operator and operands.
428 * @param i the instruction to mutate
429 * @param o the instruction's operator
430 * @param Cond1 the instruction's Cond1 operand
431 * @param Target1 the instruction's Target1 operand
432 * @param BranchProfile1 the instruction's BranchProfile1 operand
433 * @param Cond2 the instruction's Cond2 operand
434 * @param Target2 the instruction's Target2 operand
435 * @param BranchProfile2 the instruction's BranchProfile2 operand
436 * @return the mutated instruction
437 */
438 public static Instruction mutate(Instruction i, Operator o
439 , IA32ConditionOperand Cond1
440 , BranchOperand Target1
441 , BranchProfileOperand BranchProfile1
442 , IA32ConditionOperand Cond2
443 , BranchOperand Target2
444 , BranchProfileOperand BranchProfile2
445 )
446 {
447 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondBranch2");
448 i.resizeNumberOfOperands(6);
449
450 i.operator = o;
451 i.putOperand(0, Cond1);
452 i.putOperand(1, Target1);
453 i.putOperand(2, BranchProfile1);
454 i.putOperand(3, Cond2);
455 i.putOperand(4, Target2);
456 i.putOperand(5, BranchProfile2);
457 return i;
458 }
459 /**
460 * Create an instruction of the MIR_CondBranch2 instruction format.
461 * @param o the instruction's operator
462 * @param Cond1 the instruction's Cond1 operand
463 * @param Target1 the instruction's Target1 operand
464 * @param BranchProfile1 the instruction's BranchProfile1 operand
465 * @param Cond2 the instruction's Cond2 operand
466 * @param BranchProfile2 the instruction's BranchProfile2 operand
467 * @return the newly created MIR_CondBranch2 instruction
468 */
469 public static Instruction create(Operator o
470 , IA32ConditionOperand Cond1
471 , BranchOperand Target1
472 , BranchProfileOperand BranchProfile1
473 , IA32ConditionOperand Cond2
474 , BranchProfileOperand BranchProfile2
475 )
476 {
477 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondBranch2");
478 Instruction i = new Instruction(o, 6);
479 i.putOperand(0, Cond1);
480 i.putOperand(1, Target1);
481 i.putOperand(2, BranchProfile1);
482 i.putOperand(3, Cond2);
483 i.putOperand(5, BranchProfile2);
484 return i;
485 }
486
487 /**
488 * Mutate the argument instruction into an instruction of the
489 * MIR_CondBranch2 instruction format having the specified
490 * operator and operands.
491 * @param i the instruction to mutate
492 * @param o the instruction's operator
493 * @param Cond1 the instruction's Cond1 operand
494 * @param Target1 the instruction's Target1 operand
495 * @param BranchProfile1 the instruction's BranchProfile1 operand
496 * @param Cond2 the instruction's Cond2 operand
497 * @param BranchProfile2 the instruction's BranchProfile2 operand
498 * @return the mutated instruction
499 */
500 public static Instruction mutate(Instruction i, Operator o
501 , IA32ConditionOperand Cond1
502 , BranchOperand Target1
503 , BranchProfileOperand BranchProfile1
504 , IA32ConditionOperand Cond2
505 , BranchProfileOperand BranchProfile2
506 )
507 {
508 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondBranch2");
509 i.resizeNumberOfOperands(6);
510
511 i.operator = o;
512 i.putOperand(0, Cond1);
513 i.putOperand(1, Target1);
514 i.putOperand(2, BranchProfile1);
515 i.putOperand(3, Cond2);
516 i.putOperand(4, null);
517 i.putOperand(5, BranchProfile2);
518 return i;
519 }
520 /**
521 * Create an instruction of the MIR_CondBranch2 instruction format.
522 * @param o the instruction's operator
523 * @param Cond1 the instruction's Cond1 operand
524 * @param BranchProfile1 the instruction's BranchProfile1 operand
525 * @param Cond2 the instruction's Cond2 operand
526 * @param Target2 the instruction's Target2 operand
527 * @param BranchProfile2 the instruction's BranchProfile2 operand
528 * @return the newly created MIR_CondBranch2 instruction
529 */
530 public static Instruction create(Operator o
531 , IA32ConditionOperand Cond1
532 , BranchProfileOperand BranchProfile1
533 , IA32ConditionOperand Cond2
534 , BranchOperand Target2
535 , BranchProfileOperand BranchProfile2
536 )
537 {
538 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondBranch2");
539 Instruction i = new Instruction(o, 6);
540 i.putOperand(0, Cond1);
541 i.putOperand(2, BranchProfile1);
542 i.putOperand(3, Cond2);
543 i.putOperand(4, Target2);
544 i.putOperand(5, BranchProfile2);
545 return i;
546 }
547
548 /**
549 * Mutate the argument instruction into an instruction of the
550 * MIR_CondBranch2 instruction format having the specified
551 * operator and operands.
552 * @param i the instruction to mutate
553 * @param o the instruction's operator
554 * @param Cond1 the instruction's Cond1 operand
555 * @param BranchProfile1 the instruction's BranchProfile1 operand
556 * @param Cond2 the instruction's Cond2 operand
557 * @param Target2 the instruction's Target2 operand
558 * @param BranchProfile2 the instruction's BranchProfile2 operand
559 * @return the mutated instruction
560 */
561 public static Instruction mutate(Instruction i, Operator o
562 , IA32ConditionOperand Cond1
563 , BranchProfileOperand BranchProfile1
564 , IA32ConditionOperand Cond2
565 , BranchOperand Target2
566 , BranchProfileOperand BranchProfile2
567 )
568 {
569 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondBranch2");
570 i.resizeNumberOfOperands(6);
571
572 i.operator = o;
573 i.putOperand(0, Cond1);
574 i.putOperand(1, null);
575 i.putOperand(2, BranchProfile1);
576 i.putOperand(3, Cond2);
577 i.putOperand(4, Target2);
578 i.putOperand(5, BranchProfile2);
579 return i;
580 }
581 /**
582 * Create an instruction of the MIR_CondBranch2 instruction format.
583 * @param o the instruction's operator
584 * @param Cond1 the instruction's Cond1 operand
585 * @param BranchProfile1 the instruction's BranchProfile1 operand
586 * @param Cond2 the instruction's Cond2 operand
587 * @param BranchProfile2 the instruction's BranchProfile2 operand
588 * @return the newly created MIR_CondBranch2 instruction
589 */
590 public static Instruction create(Operator o
591 , IA32ConditionOperand Cond1
592 , BranchProfileOperand BranchProfile1
593 , IA32ConditionOperand Cond2
594 , BranchProfileOperand BranchProfile2
595 )
596 {
597 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondBranch2");
598 Instruction i = new Instruction(o, 6);
599 i.putOperand(0, Cond1);
600 i.putOperand(2, BranchProfile1);
601 i.putOperand(3, Cond2);
602 i.putOperand(5, BranchProfile2);
603 return i;
604 }
605
606 /**
607 * Mutate the argument instruction into an instruction of the
608 * MIR_CondBranch2 instruction format having the specified
609 * operator and operands.
610 * @param i the instruction to mutate
611 * @param o the instruction's operator
612 * @param Cond1 the instruction's Cond1 operand
613 * @param BranchProfile1 the instruction's BranchProfile1 operand
614 * @param Cond2 the instruction's Cond2 operand
615 * @param BranchProfile2 the instruction's BranchProfile2 operand
616 * @return the mutated instruction
617 */
618 public static Instruction mutate(Instruction i, Operator o
619 , IA32ConditionOperand Cond1
620 , BranchProfileOperand BranchProfile1
621 , IA32ConditionOperand Cond2
622 , BranchProfileOperand BranchProfile2
623 )
624 {
625 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "MIR_CondBranch2");
626 i.resizeNumberOfOperands(6);
627
628 i.operator = o;
629 i.putOperand(0, Cond1);
630 i.putOperand(1, null);
631 i.putOperand(2, BranchProfile1);
632 i.putOperand(3, Cond2);
633 i.putOperand(4, null);
634 i.putOperand(5, BranchProfile2);
635 return i;
636 }
637 }
638