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 IfCmp2 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 IfCmp2 extends InstructionFormat { 022 /** 023 * InstructionFormat identification method for IfCmp2. 024 * @param i an instruction 025 * @return <code>true</code> if the InstructionFormat of the argument 026 * instruction is IfCmp2 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 IfCmp2. 034 * @param o an instruction 035 * @return <code>true</code> if the InstructionFormat of the argument 036 * operator is IfCmp2 or <code>false</code> 037 * if it is not. 038 */ 039 public static boolean conforms(Operator o) { 040 return o.format == IfCmp2_format; 041 } 042 043 /** 044 * Get the operand called GuardResult 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 GuardResult 049 */ 050 public static RegisterOperand getGuardResult(Instruction i) { 051 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 052 return (RegisterOperand) i.getOperand(0); 053 } 054 /** 055 * Get the operand called GuardResult 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 GuardResult 060 */ 061 public static RegisterOperand getClearGuardResult(Instruction i) { 062 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 063 return (RegisterOperand) i.getClearOperand(0); 064 } 065 /** 066 * Set the operand called GuardResult 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 GuardResult the operand to store 072 */ 073 public static void setGuardResult(Instruction i, RegisterOperand GuardResult) { 074 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 075 i.putOperand(0, GuardResult); 076 } 077 /** 078 * Return the index of the operand called GuardResult 079 * in the argument instruction. 080 * @param i the instruction to access. 081 * @return the index of the operand called GuardResult 082 * in the argument instruction 083 */ 084 public static int indexOfGuardResult(Instruction i) { 085 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 086 return 0; 087 } 088 /** 089 * Does the argument instruction have a non-null 090 * operand named GuardResult? 091 * @param i the instruction to access. 092 * @return <code>true</code> if the instruction has an non-null 093 * operand named GuardResult or <code>false</code> 094 * if it does not. 095 */ 096 public static boolean hasGuardResult(Instruction i) { 097 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 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, "IfCmp2"); 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, "IfCmp2"); 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, "IfCmp2"); 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, "IfCmp2"); 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, "IfCmp2"); 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, "IfCmp2"); 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, "IfCmp2"); 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, "IfCmp2"); 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, "IfCmp2"); 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, "IfCmp2"); 214 return i.getOperand(2) != null; 215 } 216 217 /** 218 * Get the operand called Cond1 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 Cond1 223 */ 224 public static ConditionOperand getCond1(Instruction i) { 225 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 226 return (ConditionOperand) i.getOperand(3); 227 } 228 /** 229 * Get the operand called Cond1 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 Cond1 234 */ 235 public static ConditionOperand getClearCond1(Instruction i) { 236 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 237 return (ConditionOperand) i.getClearOperand(3); 238 } 239 /** 240 * Set the operand called Cond1 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 Cond1 the operand to store 246 */ 247 public static void setCond1(Instruction i, ConditionOperand Cond1) { 248 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 249 i.putOperand(3, Cond1); 250 } 251 /** 252 * Return the index of the operand called Cond1 253 * in the argument instruction. 254 * @param i the instruction to access. 255 * @return the index of the operand called Cond1 256 * in the argument instruction 257 */ 258 public static int indexOfCond1(Instruction i) { 259 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 260 return 3; 261 } 262 /** 263 * Does the argument instruction have a non-null 264 * operand named Cond1? 265 * @param i the instruction to access. 266 * @return <code>true</code> if the instruction has an non-null 267 * operand named Cond1 or <code>false</code> 268 * if it does not. 269 */ 270 public static boolean hasCond1(Instruction i) { 271 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 272 return i.getOperand(3) != null; 273 } 274 275 /** 276 * Get the operand called Target1 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 Target1 281 */ 282 public static BranchOperand getTarget1(Instruction i) { 283 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 284 return (BranchOperand) i.getOperand(4); 285 } 286 /** 287 * Get the operand called Target1 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 Target1 292 */ 293 public static BranchOperand getClearTarget1(Instruction i) { 294 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 295 return (BranchOperand) i.getClearOperand(4); 296 } 297 /** 298 * Set the operand called Target1 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 Target1 the operand to store 304 */ 305 public static void setTarget1(Instruction i, BranchOperand Target1) { 306 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 307 i.putOperand(4, Target1); 308 } 309 /** 310 * Return the index of the operand called Target1 311 * in the argument instruction. 312 * @param i the instruction to access. 313 * @return the index of the operand called Target1 314 * in the argument instruction 315 */ 316 public static int indexOfTarget1(Instruction i) { 317 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 318 return 4; 319 } 320 /** 321 * Does the argument instruction have a non-null 322 * operand named Target1? 323 * @param i the instruction to access. 324 * @return <code>true</code> if the instruction has an non-null 325 * operand named Target1 or <code>false</code> 326 * if it does not. 327 */ 328 public static boolean hasTarget1(Instruction i) { 329 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 330 return i.getOperand(4) != null; 331 } 332 333 /** 334 * Get the operand called BranchProfile1 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 BranchProfile1 339 */ 340 public static BranchProfileOperand getBranchProfile1(Instruction i) { 341 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 342 return (BranchProfileOperand) i.getOperand(5); 343 } 344 /** 345 * Get the operand called BranchProfile1 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 BranchProfile1 350 */ 351 public static BranchProfileOperand getClearBranchProfile1(Instruction i) { 352 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 353 return (BranchProfileOperand) i.getClearOperand(5); 354 } 355 /** 356 * Set the operand called BranchProfile1 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 BranchProfile1 the operand to store 362 */ 363 public static void setBranchProfile1(Instruction i, BranchProfileOperand BranchProfile1) { 364 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 365 i.putOperand(5, BranchProfile1); 366 } 367 /** 368 * Return the index of the operand called BranchProfile1 369 * in the argument instruction. 370 * @param i the instruction to access. 371 * @return the index of the operand called BranchProfile1 372 * in the argument instruction 373 */ 374 public static int indexOfBranchProfile1(Instruction i) { 375 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 376 return 5; 377 } 378 /** 379 * Does the argument instruction have a non-null 380 * operand named BranchProfile1? 381 * @param i the instruction to access. 382 * @return <code>true</code> if the instruction has an non-null 383 * operand named BranchProfile1 or <code>false</code> 384 * if it does not. 385 */ 386 public static boolean hasBranchProfile1(Instruction i) { 387 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 388 return i.getOperand(5) != null; 389 } 390 391 /** 392 * Get the operand called Cond2 from the 393 * argument instruction. Note that the returned operand 394 * will still point to its containing instruction. 395 * @param i the instruction to fetch the operand from 396 * @return the operand called Cond2 397 */ 398 public static ConditionOperand getCond2(Instruction i) { 399 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 400 return (ConditionOperand) i.getOperand(6); 401 } 402 /** 403 * Get the operand called Cond2 from the argument 404 * instruction clearing its instruction pointer. The returned 405 * operand will not point to any containing instruction. 406 * @param i the instruction to fetch the operand from 407 * @return the operand called Cond2 408 */ 409 public static ConditionOperand getClearCond2(Instruction i) { 410 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 411 return (ConditionOperand) i.getClearOperand(6); 412 } 413 /** 414 * Set the operand called Cond2 in the argument 415 * instruction to the argument operand. The operand will 416 * now point to the argument instruction as its containing 417 * instruction. 418 * @param i the instruction in which to store the operand 419 * @param Cond2 the operand to store 420 */ 421 public static void setCond2(Instruction i, ConditionOperand Cond2) { 422 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 423 i.putOperand(6, Cond2); 424 } 425 /** 426 * Return the index of the operand called Cond2 427 * in the argument instruction. 428 * @param i the instruction to access. 429 * @return the index of the operand called Cond2 430 * in the argument instruction 431 */ 432 public static int indexOfCond2(Instruction i) { 433 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 434 return 6; 435 } 436 /** 437 * Does the argument instruction have a non-null 438 * operand named Cond2? 439 * @param i the instruction to access. 440 * @return <code>true</code> if the instruction has an non-null 441 * operand named Cond2 or <code>false</code> 442 * if it does not. 443 */ 444 public static boolean hasCond2(Instruction i) { 445 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 446 return i.getOperand(6) != null; 447 } 448 449 /** 450 * Get the operand called Target2 from the 451 * argument instruction. Note that the returned operand 452 * will still point to its containing instruction. 453 * @param i the instruction to fetch the operand from 454 * @return the operand called Target2 455 */ 456 public static BranchOperand getTarget2(Instruction i) { 457 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 458 return (BranchOperand) i.getOperand(7); 459 } 460 /** 461 * Get the operand called Target2 from the argument 462 * instruction clearing its instruction pointer. The returned 463 * operand will not point to any containing instruction. 464 * @param i the instruction to fetch the operand from 465 * @return the operand called Target2 466 */ 467 public static BranchOperand getClearTarget2(Instruction i) { 468 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 469 return (BranchOperand) i.getClearOperand(7); 470 } 471 /** 472 * Set the operand called Target2 in the argument 473 * instruction to the argument operand. The operand will 474 * now point to the argument instruction as its containing 475 * instruction. 476 * @param i the instruction in which to store the operand 477 * @param Target2 the operand to store 478 */ 479 public static void setTarget2(Instruction i, BranchOperand Target2) { 480 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 481 i.putOperand(7, Target2); 482 } 483 /** 484 * Return the index of the operand called Target2 485 * in the argument instruction. 486 * @param i the instruction to access. 487 * @return the index of the operand called Target2 488 * in the argument instruction 489 */ 490 public static int indexOfTarget2(Instruction i) { 491 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 492 return 7; 493 } 494 /** 495 * Does the argument instruction have a non-null 496 * operand named Target2? 497 * @param i the instruction to access. 498 * @return <code>true</code> if the instruction has an non-null 499 * operand named Target2 or <code>false</code> 500 * if it does not. 501 */ 502 public static boolean hasTarget2(Instruction i) { 503 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 504 return i.getOperand(7) != null; 505 } 506 507 /** 508 * Get the operand called BranchProfile2 from the 509 * argument instruction. Note that the returned operand 510 * will still point to its containing instruction. 511 * @param i the instruction to fetch the operand from 512 * @return the operand called BranchProfile2 513 */ 514 public static BranchProfileOperand getBranchProfile2(Instruction i) { 515 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 516 return (BranchProfileOperand) i.getOperand(8); 517 } 518 /** 519 * Get the operand called BranchProfile2 from the argument 520 * instruction clearing its instruction pointer. The returned 521 * operand will not point to any containing instruction. 522 * @param i the instruction to fetch the operand from 523 * @return the operand called BranchProfile2 524 */ 525 public static BranchProfileOperand getClearBranchProfile2(Instruction i) { 526 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 527 return (BranchProfileOperand) i.getClearOperand(8); 528 } 529 /** 530 * Set the operand called BranchProfile2 in the argument 531 * instruction to the argument operand. The operand will 532 * now point to the argument instruction as its containing 533 * instruction. 534 * @param i the instruction in which to store the operand 535 * @param BranchProfile2 the operand to store 536 */ 537 public static void setBranchProfile2(Instruction i, BranchProfileOperand BranchProfile2) { 538 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 539 i.putOperand(8, BranchProfile2); 540 } 541 /** 542 * Return the index of the operand called BranchProfile2 543 * in the argument instruction. 544 * @param i the instruction to access. 545 * @return the index of the operand called BranchProfile2 546 * in the argument instruction 547 */ 548 public static int indexOfBranchProfile2(Instruction i) { 549 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 550 return 8; 551 } 552 /** 553 * Does the argument instruction have a non-null 554 * operand named BranchProfile2? 555 * @param i the instruction to access. 556 * @return <code>true</code> if the instruction has an non-null 557 * operand named BranchProfile2 or <code>false</code> 558 * if it does not. 559 */ 560 public static boolean hasBranchProfile2(Instruction i) { 561 if (Configuration.ExtremeAssertions && !conforms(i)) fail(i, "IfCmp2"); 562 return i.getOperand(8) != null; 563 } 564 565 566 /** 567 * Create an instruction of the IfCmp2 instruction format. 568 * @param o the instruction's operator 569 * @param GuardResult the instruction's GuardResult operand 570 * @param Val1 the instruction's Val1 operand 571 * @param Val2 the instruction's Val2 operand 572 * @param Cond1 the instruction's Cond1 operand 573 * @param Target1 the instruction's Target1 operand 574 * @param BranchProfile1 the instruction's BranchProfile1 operand 575 * @param Cond2 the instruction's Cond2 operand 576 * @param Target2 the instruction's Target2 operand 577 * @param BranchProfile2 the instruction's BranchProfile2 operand 578 * @return the newly created IfCmp2 instruction 579 */ 580 public static Instruction create(Operator o 581 , RegisterOperand GuardResult 582 , Operand Val1 583 , Operand Val2 584 , ConditionOperand Cond1 585 , BranchOperand Target1 586 , BranchProfileOperand BranchProfile1 587 , ConditionOperand Cond2 588 , BranchOperand Target2 589 , BranchProfileOperand BranchProfile2 590 ) 591 { 592 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "IfCmp2"); 593 Instruction i = Instruction.create(o, 9); 594 i.putOperand(0, GuardResult); 595 i.putOperand(1, Val1); 596 i.putOperand(2, Val2); 597 i.putOperand(3, Cond1); 598 i.putOperand(4, Target1); 599 i.putOperand(5, BranchProfile1); 600 i.putOperand(6, Cond2); 601 i.putOperand(7, Target2); 602 i.putOperand(8, BranchProfile2); 603 return i; 604 } 605 606 /** 607 * Mutate the argument instruction into an instruction of the 608 * IfCmp2 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 GuardResult the instruction's GuardResult operand 613 * @param Val1 the instruction's Val1 operand 614 * @param Val2 the instruction's Val2 operand 615 * @param Cond1 the instruction's Cond1 operand 616 * @param Target1 the instruction's Target1 operand 617 * @param BranchProfile1 the instruction's BranchProfile1 operand 618 * @param Cond2 the instruction's Cond2 operand 619 * @param Target2 the instruction's Target2 operand 620 * @param BranchProfile2 the instruction's BranchProfile2 operand 621 * @return the mutated instruction 622 */ 623 public static Instruction mutate(Instruction i, Operator o 624 , RegisterOperand GuardResult 625 , Operand Val1 626 , Operand Val2 627 , ConditionOperand Cond1 628 , BranchOperand Target1 629 , BranchProfileOperand BranchProfile1 630 , ConditionOperand Cond2 631 , BranchOperand Target2 632 , BranchProfileOperand BranchProfile2 633 ) 634 { 635 if (Configuration.ExtremeAssertions && !conforms(o)) fail(o, "IfCmp2"); 636 i.resizeNumberOfOperands(9); 637 638 i.changeOperatorTo(o); 639 i.putOperand(0, GuardResult); 640 i.putOperand(1, Val1); 641 i.putOperand(2, Val2); 642 i.putOperand(3, Cond1); 643 i.putOperand(4, Target1); 644 i.putOperand(5, BranchProfile1); 645 i.putOperand(6, Cond2); 646 i.putOperand(7, Target2); 647 i.putOperand(8, BranchProfile2); 648 return i; 649 } 650} 651