1 /*
   2  * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package jdk.incubator.code.bytecode;
  27 
  28 import java.lang.classfile.ClassBuilder;
  29 import java.lang.classfile.ClassFile;
  30 import java.lang.classfile.ClassModel;
  31 import java.lang.classfile.CodeBuilder;
  32 import java.lang.classfile.Label;
  33 import java.lang.classfile.Opcode;
  34 import java.lang.classfile.TypeKind;
  35 import java.lang.constant.ClassDesc;
  36 import java.lang.constant.Constable;
  37 import java.lang.constant.ConstantDescs;
  38 import java.lang.constant.DirectMethodHandleDesc;
  39 import java.lang.constant.DynamicCallSiteDesc;
  40 import java.lang.constant.MethodHandleDesc;
  41 import java.lang.constant.MethodTypeDesc;
  42 import java.lang.invoke.LambdaMetafactory;
  43 import java.lang.invoke.MethodHandle;
  44 import java.lang.invoke.MethodHandles;
  45 import java.lang.invoke.MethodType;
  46 import java.lang.invoke.StringConcatFactory;
  47 import java.lang.reflect.Method;
  48 import java.lang.reflect.Modifier;
  49 import jdk.incubator.code.Block;
  50 import jdk.incubator.code.Op;
  51 import jdk.incubator.code.Quotable;
  52 import jdk.incubator.code.Quoted;
  53 import jdk.incubator.code.TypeElement;
  54 import jdk.incubator.code.Value;
  55 import jdk.incubator.code.bytecode.impl.BranchCompactor;
  56 import jdk.incubator.code.bytecode.impl.LocalsCompactor;
  57 import jdk.incubator.code.dialect.core.CoreOp.*;
  58 import jdk.incubator.code.dialect.java.*;
  59 import jdk.incubator.code.extern.OpParser;
  60 import jdk.incubator.code.dialect.core.FunctionType;
  61 import jdk.incubator.code.dialect.core.VarType;
  62 import java.util.ArrayList;
  63 import java.util.Arrays;
  64 import java.util.BitSet;
  65 import java.util.IdentityHashMap;
  66 import java.util.List;
  67 import java.util.Map;
  68 import java.util.Set;
  69 import java.util.stream.Stream;
  70 
  71 import static java.lang.constant.ConstantDescs.*;
  72 import static jdk.incubator.code.dialect.java.JavaOp.*;
  73 
  74 /**
  75  * Transformer of code models to bytecode.
  76  */
  77 public final class BytecodeGenerator {
  78 
  79     private static final DirectMethodHandleDesc DMHD_LAMBDA_METAFACTORY = ofCallsiteBootstrap(
  80             LambdaMetafactory.class.describeConstable().orElseThrow(),
  81             "metafactory",
  82             CD_CallSite, CD_MethodType, CD_MethodHandle, CD_MethodType);
  83 
  84     private static final DirectMethodHandleDesc DMHD_LAMBDA_ALT_METAFACTORY = ofCallsiteBootstrap(
  85             LambdaMetafactory.class.describeConstable().orElseThrow(),
  86             "altMetafactory",
  87             CD_CallSite, CD_Object.arrayType());
  88 
  89     private static final DirectMethodHandleDesc DMHD_STRING_CONCAT = ofCallsiteBootstrap(
  90             StringConcatFactory.class.describeConstable().orElseThrow(),
  91             "makeConcat",
  92             CD_CallSite);
  93 
  94     private static final MethodTypeDesc OP_METHOD_DESC = MethodTypeDesc.of(Op.class.describeConstable().get());
  95 
  96     /**
  97      * Transforms the invokable operation to bytecode encapsulated in a method of hidden class and exposed
  98      * for invocation via a method handle.
  99      *
 100      * @param l the lookup
 101      * @param iop the invokable operation to transform to bytecode
 102      * @return the invoking method handle
 103      * @param <O> the type of the invokable operation
 104      */
 105     public static <O extends Op & Op.Invokable> MethodHandle generate(MethodHandles.Lookup l, O iop) {
 106         String name = iop instanceof FuncOp fop ? fop.funcName() : "m";
 107         byte[] classBytes = generateClassData(l, name, iop);
 108 
 109         MethodHandles.Lookup hcl;
 110         try {
 111             hcl = l.defineHiddenClass(classBytes, true, MethodHandles.Lookup.ClassOption.NESTMATE);
 112         } catch (IllegalAccessException e) {
 113             throw new RuntimeException(e);
 114         }
 115 
 116         try {
 117             FunctionType ft = iop.invokableType();
 118             MethodType mt = MethodRef.toNominalDescriptor(ft).resolveConstantDesc(hcl);
 119             return hcl.findStatic(hcl.lookupClass(), name, mt);
 120         } catch (ReflectiveOperationException e) {
 121             throw new RuntimeException(e);
 122         }
 123     }
 124 
 125     /**
 126      * Transforms the function operation to bytecode encapsulated in a method of a class file.
 127      * <p>
 128      * The name of the method is the function operation's {@link FuncOp#funcName() function name}.
 129      *
 130      * @param lookup the lookup
 131      * @param fop the function operation to transform to bytecode
 132      * @return the class file bytes
 133      */
 134     public static byte[] generateClassData(MethodHandles.Lookup lookup, FuncOp fop) {
 135         ClassModel generatedModel = ClassFile.of().parse(generateClassData(lookup, fop.funcName(), fop));
 136         // Compact locals of the generated bytecode
 137         return ClassFile.of().transformClass(generatedModel, LocalsCompactor.INSTANCE);
 138     }
 139 
 140     /**
 141      * Transforms the invokable operation to bytecode encapsulated in a method of a class file.
 142      *
 143      * @param lookup the lookup
 144      * @param name the name to use for the method of the class file
 145      * @param iop the invokable operation to transform to bytecode
 146      * @return the class file bytes
 147      * @param <O> the type of the invokable operation
 148      */
 149     public static <O extends Op & Op.Invokable> byte[] generateClassData(MethodHandles.Lookup lookup,
 150                                                                          String name,
 151                                                                          O iop) {
 152         if (!iop.capturedValues().isEmpty()) {
 153             throw new UnsupportedOperationException("Operation captures values");
 154         }
 155 
 156         String packageName = lookup.lookupClass().getPackageName();
 157         ClassDesc className = ClassDesc.of(packageName.isEmpty()
 158                 ? name
 159                 : packageName + "." + name);
 160         byte[] classBytes = ClassFile.of().build(className, clb -> {
 161             List<LambdaOp> lambdaSink = new ArrayList<>();
 162             BitSet quotable = new BitSet();
 163             generateMethod(lookup, className, name, iop, clb, lambdaSink, quotable);
 164             for (int i = 0; i < lambdaSink.size(); i++) {
 165                 LambdaOp lop = lambdaSink.get(i);
 166                 if (quotable.get(i)) {
 167                     // return (FuncOp) OpParser.fromOpString(opText)
 168                     clb.withMethod("op$lambda$" + i, OP_METHOD_DESC,
 169                         ClassFile.ACC_PRIVATE | ClassFile.ACC_STATIC | ClassFile.ACC_SYNTHETIC, mb -> mb.withCode(cb -> cb
 170                                 .loadConstant(Quoted.quoteOp(lop).toText())
 171                                 .invoke(Opcode.INVOKESTATIC, OpParser.class.describeConstable().get(),
 172                                         "fromStringOfJavaCodeModel",
 173                                         MethodTypeDesc.of(Op.class.describeConstable().get(), CD_String), false)
 174                                 .areturn()));
 175                 }
 176                 generateMethod(lookup, className, "lambda$" + i, lop, clb, lambdaSink, quotable);
 177             }
 178         });
 179         return classBytes;
 180     }
 181 
 182     private static <O extends Op & Op.Invokable> void generateMethod(MethodHandles.Lookup lookup,
 183                                                                      ClassDesc className,
 184                                                                      String methodName,
 185                                                                      O iop,
 186                                                                      ClassBuilder clb,
 187                                                                      List<LambdaOp> lambdaSink,
 188                                                                      BitSet quotable) {
 189 
 190         List<Value> capturedValues = iop instanceof LambdaOp lop ? lop.capturedValues() : List.of();
 191         MethodTypeDesc mtd = MethodRef.toNominalDescriptor(
 192                 iop.invokableType()).insertParameterTypes(0, capturedValues.stream()
 193                         .map(Value::type).map(BytecodeGenerator::toClassDesc).toArray(ClassDesc[]::new));
 194         clb.withMethodBody(methodName, mtd, ClassFile.ACC_PUBLIC | ClassFile.ACC_STATIC,
 195                 cb -> cb.transforming(new BranchCompactor(), cob ->
 196                     new BytecodeGenerator(lookup, className, capturedValues, TypeKind.from(mtd.returnType()),
 197                                           iop.body().blocks(), cob, lambdaSink, quotable).generate()));
 198     }
 199 
 200     private record Slot(int slot, TypeKind typeKind) {}
 201 
 202     private final MethodHandles.Lookup lookup;
 203     private final ClassDesc className;
 204     private final List<Value> capturedValues;
 205     private final TypeKind returnType;
 206     private final List<Block> blocks;
 207     private final CodeBuilder cob;
 208     private final Label[] blockLabels;
 209     private final Block[][] blocksCatchMap;
 210     private final BitSet allCatchBlocks;
 211     private final Label[] tryStartLabels;
 212     private final Map<Value, Slot> slots;
 213     private final Map<Block.Parameter, Value> singlePredecessorsValues;
 214     private final List<LambdaOp> lambdaSink;
 215     private final BitSet quotable;
 216     private final Map<Op, Boolean> deferCache;
 217     private Value oprOnStack;
 218     private Block[] recentCatchBlocks;
 219 
 220     private BytecodeGenerator(MethodHandles.Lookup lookup,
 221                               ClassDesc className,
 222                               List<Value> capturedValues,
 223                               TypeKind returnType,
 224                               List<Block> blocks,
 225                               CodeBuilder cob,
 226                               List<LambdaOp> lambdaSink,
 227                               BitSet quotable) {
 228         this.lookup = lookup;
 229         this.className = className;
 230         this.capturedValues = capturedValues;
 231         this.returnType = returnType;
 232         this.blocks = blocks;
 233         this.cob = cob;
 234         this.blockLabels = new Label[blocks.size()];
 235         this.blocksCatchMap = new Block[blocks.size()][];
 236         this.allCatchBlocks = new BitSet();
 237         this.tryStartLabels = new Label[blocks.size()];
 238         this.slots = new IdentityHashMap<>();
 239         this.singlePredecessorsValues = new IdentityHashMap<>();
 240         this.lambdaSink = lambdaSink;
 241         this.quotable = quotable;
 242         this.deferCache = new IdentityHashMap<>();
 243     }
 244 
 245     private void setCatchStack(Block.Reference target, Block[] activeCatchBlocks) {
 246         setCatchStack(target.targetBlock().index(), activeCatchBlocks);
 247     }
 248 
 249     private void setCatchStack(int blockIndex, Block[] activeCatchBlocks) {
 250         Block[] prevStack = blocksCatchMap[blockIndex];
 251         if (prevStack == null) {
 252             blocksCatchMap[blockIndex] = activeCatchBlocks;
 253         } else {
 254             assert Arrays.equals(prevStack, activeCatchBlocks);
 255         }
 256     }
 257 
 258     private Label getLabel(Block.Reference target) {
 259         return getLabel(target.targetBlock().index());
 260     }
 261 
 262     private Label getLabel(int blockIndex) {
 263         if (blockIndex == blockLabels.length) {
 264             return cob.endLabel();
 265         }
 266         Label l = blockLabels[blockIndex];
 267         if (l == null) {
 268             blockLabels[blockIndex] = l = cob.newLabel();
 269         }
 270         return l;
 271     }
 272 
 273     private Slot allocateSlot(Value v) {
 274         return slots.computeIfAbsent(v, _ -> {
 275             TypeKind tk = toTypeKind(v.type());
 276             return new Slot(cob.allocateLocal(tk), tk);
 277         });
 278     }
 279 
 280     private void storeIfUsed(Value v) {
 281         if (!v.uses().isEmpty()) {
 282             Slot slot = allocateSlot(v);
 283             cob.storeLocal(slot.typeKind(), slot.slot());
 284         } else {
 285             // Only pop results from stack if the value has no further use (no valid slot)
 286             switch (toTypeKind(v.type()).slotSize()) {
 287                 case 1 -> cob.pop();
 288                 case 2 -> cob.pop2();
 289             }
 290         }
 291     }
 292 
 293     private void load(Value v) {
 294         v = singlePredecessorsValues.getOrDefault(v, v);
 295         if (v instanceof Op.Result or &&
 296                 or.op() instanceof ConstantOp constantOp &&
 297                 !constantOp.resultType().equals(JavaType.J_L_CLASS)) {
 298             cob.loadConstant(switch (constantOp.value()) {
 299                 case null -> null;
 300                 case Boolean b -> {
 301                     yield b ? 1 : 0;
 302                 }
 303                 case Byte b -> (int)b;
 304                 case Character ch -> (int)ch;
 305                 case Short s -> (int)s;
 306                 case Constable c -> c.describeConstable().orElseThrow();
 307                 default -> throw new IllegalArgumentException("Unexpected constant value: " + constantOp.value());
 308             });
 309         } else {
 310             Slot slot = slots.get(v);
 311             if (slot == null) {
 312                 if (v instanceof Op.Result or) {
 313                     // Handling of deferred variables
 314                     switch (or.op()) {
 315                         case VarOp vop ->
 316                             load(vop.initOperand());
 317                         case VarAccessOp.VarLoadOp vlop ->
 318                             load(vlop.varOperand());
 319                         default ->
 320                             throw new IllegalStateException("Missing slot for: " + or.op());
 321                     }
 322                 } else {
 323                     throw new IllegalStateException("Missing slot for: " + v);
 324                 }
 325             } else {
 326                 cob.loadLocal(slot.typeKind(), slot.slot());
 327             }
 328         }
 329     }
 330 
 331     private void processFirstOperand(Op op) {
 332         processOperand(op.operands().getFirst());
 333     }
 334 
 335     private void processOperand(Value operand) {
 336         if (oprOnStack == null) {
 337             load(operand);
 338         } else {
 339             assert oprOnStack == operand;
 340             oprOnStack = null;
 341         }
 342     }
 343 
 344     private void processOperands(Op op) {
 345         processOperands(op.operands());
 346     }
 347 
 348     private void processOperands(List<Value> operands) {
 349         if (oprOnStack == null) {
 350             operands.forEach(this::load);
 351         } else {
 352             assert !operands.isEmpty() && oprOnStack == operands.getFirst();
 353             oprOnStack = null;
 354             for (int i = 1; i < operands.size(); i++) {
 355                 load(operands.get(i));
 356             }
 357         }
 358     }
 359 
 360     // Some of the operations can be deferred
 361     private boolean canDefer(Op op) {
 362         Boolean can = deferCache.get(op);
 363         if (can == null) {
 364             can = switch (op) {
 365                 case ConstantOp cop -> canDefer(cop);
 366                 case VarOp vop -> canDefer(vop);
 367                 case VarAccessOp.VarLoadOp vlop -> canDefer(vlop);
 368                 default -> false;
 369             };
 370             deferCache.put(op, can);
 371         }
 372         return can;
 373     }
 374 
 375     // Constant can be deferred, except for loading of a class constant, which  may throw an exception
 376     private static boolean canDefer(ConstantOp op) {
 377         return !op.resultType().equals(JavaType.J_L_CLASS);
 378     }
 379 
 380     // Single-use var or var with a single-use entry block parameter operand can be deferred
 381     private static boolean canDefer(VarOp op) {
 382         return op.isUninitialized()
 383             || !moreThanOneUse(op.result())
 384             || op.initOperand() instanceof Block.Parameter bp && bp.declaringBlock().isEntryBlock() && !moreThanOneUse(bp);
 385     }
 386 
 387     // Var load can be deferred when not used as immediate operand
 388     private boolean canDefer(VarAccessOp.VarLoadOp op) {
 389         return !isNextUse(op.result());
 390     }
 391 
 392     // This method narrows the first operand inconveniences of some operations
 393     private static boolean isFirstOperand(Op nextOp, Value opr) {
 394         List<Value> values;
 395         return switch (nextOp) {
 396             // When there is no next operation
 397             case null -> false;
 398             // New object cannot use first operand from stack, new array fall through to the default
 399             case NewOp op when !(op.constructorDescriptor().type().returnType() instanceof ArrayType) ->
 400                 false;
 401             // For lambda the effective operands are captured values
 402             case LambdaOp op ->
 403                 !(values = op.capturedValues()).isEmpty() && values.getFirst() == opr;
 404             // Conditional branch may delegate to its binary test operation
 405             case ConditionalBranchOp op when getConditionForCondBrOp(op) instanceof BinaryTestOp bto ->
 406                 isFirstOperand(bto, opr);
 407             // Var store effective first operand is not the first one
 408             case VarAccessOp.VarStoreOp op ->
 409                 op.operands().get(1) == opr;
 410             // Unconditional branch first target block argument
 411             case BranchOp op ->
 412                 !(values = op.branch().arguments()).isEmpty() && values.getFirst() == opr;
 413             // regular check of the first operand
 414             default ->
 415                 !(values = nextOp.operands()).isEmpty() && values.getFirst() == opr;
 416         };
 417     }
 418 
 419     // Determines if the operation result is immediatelly used by the next operation and so can stay on stack
 420     private boolean isNextUse(Value opr) {
 421         Op nextOp = switch (opr) {
 422             case Block.Parameter p -> p.declaringBlock().firstOp();
 423             case Op.Result r -> r.declaringBlock().nextOp(r.op());
 424         };
 425         // Pass over deferred operations
 426         while (canDefer(nextOp)) {
 427             nextOp = nextOp.ancestorBlock().nextOp(nextOp);
 428         }
 429         return isFirstOperand(nextOp, opr);
 430     }
 431 
 432     private static boolean isConditionForCondBrOp(BinaryTestOp op) {
 433         // Result of op has one use as the operand of a CondBrOp op,
 434         // and both ops are in the same block
 435 
 436         Set<Op.Result> uses = op.result().uses();
 437         if (uses.size() != 1) {
 438             return false;
 439         }
 440         Op.Result use = uses.iterator().next();
 441 
 442         if (use.declaringBlock() != op.ancestorBlock()) {
 443             return false;
 444         }
 445 
 446         // Check if used in successor
 447         for (Block.Reference s : use.op().successors()) {
 448             if (s.arguments().contains(op.result())) {
 449                 return false;
 450             }
 451         }
 452 
 453         return use.op() instanceof ConditionalBranchOp;
 454     }
 455 
 456     static ClassDesc toClassDesc(TypeElement t) {
 457         return switch (t) {
 458             case VarType vt -> toClassDesc(vt.valueType());
 459             case JavaType jt -> jt.toNominalDescriptor();
 460             default ->
 461                 throw new IllegalArgumentException("Bad type: " + t);
 462         };
 463     }
 464 
 465     static TypeKind toTypeKind(TypeElement t) {
 466         return switch (t) {
 467             case VarType vt -> toTypeKind(vt.valueType());
 468             case PrimitiveType pt -> TypeKind.from(pt.toNominalDescriptor());
 469             case JavaType _ -> TypeKind.REFERENCE;
 470             default ->
 471                 throw new IllegalArgumentException("Bad type: " + t);
 472         };
 473     }
 474 
 475     private void generate() {
 476         recentCatchBlocks = new Block[0];
 477 
 478         Block entryBlock = blocks.getFirst();
 479         assert entryBlock.isEntryBlock();
 480 
 481         // Entry block parameters conservatively require slots
 482         // Some unused parameters might be declared before others that are used
 483         List<Block.Parameter> parameters = entryBlock.parameters();
 484         int paramSlot = 0;
 485         // Captured values prepend parameters in lambda impl methods
 486         for (Value cv : capturedValues) {
 487             slots.put(cv, new Slot(cob.parameterSlot(paramSlot++), toTypeKind(cv.type())));
 488         }
 489         for (Block.Parameter bp : parameters) {
 490             slots.put(bp, new Slot(cob.parameterSlot(paramSlot++), toTypeKind(bp.type())));
 491         }
 492 
 493         blocksCatchMap[entryBlock.index()] = new Block[0];
 494 
 495         // Process blocks in topological order
 496         // A jump instruction assumes the false successor block is
 497         // immediately after, in sequence, to the predecessor
 498         // since the jump instructions branch on a true condition
 499         // Conditions are inverted when lowered to bytecode
 500         for (Block b : blocks) {
 501 
 502             Block[] catchBlocks = blocksCatchMap[b.index()];
 503 
 504             // Ignore inaccessible blocks
 505             if (catchBlocks == null) {
 506                 continue;
 507             }
 508 
 509             Label blockLabel = getLabel(b.index());
 510             cob.labelBinding(blockLabel);
 511 
 512             oprOnStack = null;
 513 
 514             // If b is a catch block then the exception argument will be represented on the stack
 515             if (allCatchBlocks.get(b.index())) {
 516                 // Retain block argument for exception table generation
 517                 push(b.parameters().getFirst());
 518             }
 519 
 520             exceptionRegionsChange(catchBlocks);
 521 
 522             List<Op> ops = b.ops();
 523             for (int i = 0; i < ops.size() - 1; i++) {
 524                 final Op o = ops.get(i);
 525                 final TypeElement oprType = o.resultType();
 526                 final TypeKind rvt = toTypeKind(oprType);
 527                 switch (o) {
 528                     case ConstantOp op -> {
 529                         if (!canDefer(op)) {
 530                             // Constant can be deferred, except for a class constant, which  may throw an exception
 531                             Object v = op.value();
 532                             if (v == null) {
 533                                 cob.aconst_null();
 534                             } else {
 535                                 cob.ldc(((JavaType)v).toNominalDescriptor());
 536                             }
 537                             push(op.result());
 538                         }
 539                     }
 540                     case VarOp op when op.isUninitialized() -> {
 541                         // Do nothing
 542                     }
 543                     case VarOp op -> {
 544                         //     %1 : Var<int> = var %0 @"i";
 545                         if (canDefer(op)) {
 546                             Slot s = slots.get(op.operands().getFirst());
 547                             if (s != null) {
 548                                 // Var with a single-use entry block parameter can reuse its slot
 549                                 slots.put(op.result(), s);
 550                             }
 551                         } else {
 552                             processFirstOperand(op);
 553                             storeIfUsed(op.result());
 554                         }
 555                     }
 556                     case VarAccessOp.VarLoadOp op -> {
 557                         if (canDefer(op)) {
 558                             // Var load can be deferred when not used as immediate operand
 559                             slots.computeIfAbsent(op.result(), r -> slots.get(op.operands().getFirst()));
 560                         } else {
 561                             load(op.operands().getFirst());
 562                             push(op.result());
 563                         }
 564                     }
 565                     case VarAccessOp.VarStoreOp op -> {
 566                         processOperand(op.operands().get(1));
 567                         Slot slot = allocateSlot(op.operands().getFirst());
 568                         cob.storeLocal(slot.typeKind(), slot.slot());
 569                     }
 570                     case ConvOp op -> {
 571                         Value first = op.operands().getFirst();
 572                         processOperand(first);
 573                         cob.conversion(toTypeKind(first.type()), rvt);
 574                         push(op.result());
 575                     }
 576                     case NegOp op -> {
 577                         processFirstOperand(op);
 578                         switch (rvt) { //this can be moved to CodeBuilder::neg(TypeKind)
 579                             case INT, BOOLEAN, BYTE, SHORT, CHAR -> cob.ineg();
 580                             case LONG -> cob.lneg();
 581                             case FLOAT -> cob.fneg();
 582                             case DOUBLE -> cob.dneg();
 583                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 584                         }
 585                         push(op.result());
 586                     }
 587                     case ComplOp op -> {
 588                         // Lower to x ^ -1
 589                         processFirstOperand(op);
 590                         switch (rvt) {
 591                             case INT, BOOLEAN, BYTE, SHORT, CHAR -> {
 592                                 cob.iconst_m1();
 593                                 cob.ixor();
 594                             }
 595                             case LONG -> {
 596                                 cob.ldc(-1L);
 597                                 cob.lxor();
 598                             }
 599                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 600                         }
 601                         push(op.result());
 602                     }
 603                     case NotOp op -> {
 604                         processFirstOperand(op);
 605                         cob.ifThenElse(CodeBuilder::iconst_0, CodeBuilder::iconst_1);
 606                         push(op.result());
 607                     }
 608                     case AddOp op -> {
 609                         processOperands(op);
 610                         switch (rvt) { //this can be moved to CodeBuilder::add(TypeKind)
 611                             case INT, BOOLEAN, BYTE, SHORT, CHAR -> cob.iadd();
 612                             case LONG -> cob.ladd();
 613                             case FLOAT -> cob.fadd();
 614                             case DOUBLE -> cob.dadd();
 615                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 616                         }
 617                         push(op.result());
 618                     }
 619                     case SubOp op -> {
 620                         processOperands(op);
 621                         switch (rvt) { //this can be moved to CodeBuilder::sub(TypeKind)
 622                             case INT, BOOLEAN, BYTE, SHORT, CHAR -> cob.isub();
 623                             case LONG -> cob.lsub();
 624                             case FLOAT -> cob.fsub();
 625                             case DOUBLE -> cob.dsub();
 626                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 627                         }
 628                         push(op.result());
 629                     }
 630                     case MulOp op -> {
 631                         processOperands(op);
 632                         switch (rvt) { //this can be moved to CodeBuilder::mul(TypeKind)
 633                             case INT, BOOLEAN, BYTE, SHORT, CHAR -> cob.imul();
 634                             case LONG -> cob.lmul();
 635                             case FLOAT -> cob.fmul();
 636                             case DOUBLE -> cob.dmul();
 637                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 638                         }
 639                         push(op.result());
 640                     }
 641                     case DivOp op -> {
 642                         processOperands(op);
 643                         switch (rvt) { //this can be moved to CodeBuilder::div(TypeKind)
 644                             case INT, BOOLEAN, BYTE, SHORT, CHAR -> cob.idiv();
 645                             case LONG -> cob.ldiv();
 646                             case FLOAT -> cob.fdiv();
 647                             case DOUBLE -> cob.ddiv();
 648                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 649                         }
 650                         push(op.result());
 651                     }
 652                     case ModOp op -> {
 653                         processOperands(op);
 654                         switch (rvt) { //this can be moved to CodeBuilder::rem(TypeKind)
 655                             case INT, BOOLEAN, BYTE, SHORT, CHAR -> cob.irem();
 656                             case LONG -> cob.lrem();
 657                             case FLOAT -> cob.frem();
 658                             case DOUBLE -> cob.drem();
 659                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 660                         }
 661                         push(op.result());
 662                     }
 663                     case AndOp op -> {
 664                         processOperands(op);
 665                         switch (rvt) { //this can be moved to CodeBuilder::and(TypeKind)
 666                             case INT, BOOLEAN, BYTE, SHORT, CHAR -> cob.iand();
 667                             case LONG -> cob.land();
 668                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 669                         }
 670                         push(op.result());
 671                     }
 672                     case OrOp op -> {
 673                         processOperands(op);
 674                         switch (rvt) { //this can be moved to CodeBuilder::or(TypeKind)
 675                             case INT, BOOLEAN, BYTE, SHORT, CHAR -> cob.ior();
 676                             case LONG -> cob.lor();
 677                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 678                         }
 679                         push(op.result());
 680                     }
 681                     case XorOp op -> {
 682                         processOperands(op);
 683                         switch (rvt) { //this can be moved to CodeBuilder::xor(TypeKind)
 684                             case INT, BOOLEAN, BYTE, SHORT, CHAR -> cob.ixor();
 685                             case LONG -> cob.lxor();
 686                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 687                         }
 688                         push(op.result());
 689                     }
 690                     case LshlOp op -> {
 691                         processOperands(op);
 692                         adjustRightTypeToInt(op);
 693                         switch (rvt) { //this can be moved to CodeBuilder::shl(TypeKind)
 694                             case BYTE, CHAR, INT, SHORT -> cob.ishl();
 695                             case LONG -> cob.lshl();
 696                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 697                         }
 698                         push(op.result());
 699                     }
 700                     case AshrOp op -> {
 701                         processOperands(op);
 702                         adjustRightTypeToInt(op);
 703                         switch (rvt) { //this can be moved to CodeBuilder::shr(TypeKind)
 704                             case INT, BYTE, SHORT, CHAR -> cob.ishr();
 705                             case LONG -> cob.lshr();
 706                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 707                         }
 708                         push(op.result());
 709                     }
 710                     case LshrOp op -> {
 711                         processOperands(op);
 712                         adjustRightTypeToInt(op);
 713                         switch (rvt) { //this can be moved to CodeBuilder::ushr(TypeKind)
 714                             case INT, BYTE, SHORT, CHAR -> cob.iushr();
 715                             case LONG -> cob.lushr();
 716                             default -> throw new IllegalArgumentException("Bad type: " + op.resultType());
 717                         }
 718                         push(op.result());
 719                     }
 720                     case ArrayAccessOp.ArrayLoadOp op -> {
 721                         processOperands(op);
 722                         cob.arrayLoad(rvt);
 723                         push(op.result());
 724                     }
 725                     case ArrayAccessOp.ArrayStoreOp op -> {
 726                         processOperands(op);
 727                         cob.arrayStore(toTypeKind(((ArrayType)op.operands().getFirst().type()).componentType()));
 728                         push(op.result());
 729                     }
 730                     case ArrayLengthOp op -> {
 731                         processFirstOperand(op);
 732                         cob.arraylength();
 733                         push(op.result());
 734                     }
 735                     case BinaryTestOp op -> {
 736                         if (!isConditionForCondBrOp(op)) {
 737                             cob.ifThenElse(prepareConditionalBranch(op), CodeBuilder::iconst_0, CodeBuilder::iconst_1);
 738                             push(op.result());
 739                         }
 740                         // Processing is deferred to the CondBrOp, do not process the op result
 741                     }
 742                     case NewOp op -> {
 743                         switch (op.constructorDescriptor().type().returnType()) {
 744                             case ArrayType at -> {
 745                                 processOperands(op);
 746                                 if (at.dimensions() == 1) {
 747                                     ClassDesc ctd = at.componentType().toNominalDescriptor();
 748                                     if (ctd.isPrimitive()) {
 749                                         cob.newarray(TypeKind.from(ctd));
 750                                     } else {
 751                                         cob.anewarray(ctd);
 752                                     }
 753                                 } else {
 754                                     cob.multianewarray(at.toNominalDescriptor(), op.operands().size());
 755                                 }
 756                             }
 757                             case JavaType jt -> {
 758                                 cob.new_(jt.toNominalDescriptor())
 759                                     .dup();
 760                                 processOperands(op);
 761                                 cob.invokespecial(
 762                                         ((JavaType) op.resultType()).toNominalDescriptor(),
 763                                         ConstantDescs.INIT_NAME,
 764                                         MethodRef.toNominalDescriptor(op.constructorDescriptor().type())
 765                                                  .changeReturnType(ConstantDescs.CD_void));
 766                             }
 767                             default ->
 768                                 throw new IllegalArgumentException("Invalid return type: "
 769                                                                     + op.constructorDescriptor().type().returnType());
 770                         }
 771                         push(op.result());
 772                     }
 773                     case InvokeOp op -> {
 774                         if (op.isVarArgs()) {
 775                             processOperands(op.argOperands());
 776                             var varArgOperands = op.varArgOperands();
 777                             cob.loadConstant(varArgOperands.size());
 778                             var compType = ((ArrayType) op.invokeDescriptor().type().parameterTypes().getLast()).componentType();
 779                             var compTypeDesc = compType.toNominalDescriptor();
 780                             var typeKind = TypeKind.from(compTypeDesc);
 781                             if (compTypeDesc.isPrimitive()) {
 782                                 cob.newarray(typeKind);
 783                             } else {
 784                                 cob.anewarray(compTypeDesc);
 785                             }
 786                             for (int j = 0; j < varArgOperands.size(); j++) {
 787                                 // we duplicate array value on the stack to be consumed by arrayStore
 788                                 // after completion of this loop the array value will be on top of the stack
 789                                 cob.dup();
 790                                 cob.loadConstant(j);
 791                                 load(varArgOperands.get(j));
 792                                 cob.arrayStore(typeKind);
 793                             }
 794                         } else {
 795                             processOperands(op);
 796                         }
 797                         // Resolve referenced class to determine if interface
 798                         MethodRef md = op.invokeDescriptor();
 799                         JavaType refType = (JavaType)md.refType();
 800                         Class<?> refClass;
 801                         try {
 802                              refClass = (Class<?>)refType.erasure().resolve(lookup);
 803                         } catch (ReflectiveOperationException e) {
 804                             throw new IllegalArgumentException(e);
 805                         }
 806                         // Determine invoke opcode
 807                         final boolean isInterface = refClass.isInterface();
 808                         Opcode invokeOpcode = switch (op.invokeKind()) {
 809                             case STATIC ->
 810                                     Opcode.INVOKESTATIC;
 811                             case INSTANCE ->
 812                                     isInterface ? Opcode.INVOKEINTERFACE : Opcode.INVOKEVIRTUAL;
 813                             case SUPER ->
 814                                     // @@@ We cannot generate an invokespecial as it will result in a verify error,
 815                                     //     since the owner is not assignable to generated hidden class
 816                                     // @@@ Construct method handle via lookup.findSpecial
 817                                     //     using the lookup's class as the specialCaller and
 818                                     //     add that method handle to the to be defined hidden class's constant data
 819                                     //     Use and ldc+constant dynamic to access the class data,
 820                                     //     extract the method handle and then invoke it
 821                                     throw new UnsupportedOperationException("invoke super unsupported: " + op.invokeDescriptor());
 822                         };
 823                         MethodTypeDesc mDesc = MethodRef.toNominalDescriptor(md.type());
 824                         cob.invoke(
 825                                 invokeOpcode,
 826                                 refType.toNominalDescriptor(),
 827                                 md.name(),
 828                                 mDesc,
 829                                 isInterface);
 830                         ClassDesc ret = toClassDesc(op.resultType());
 831                         if (ret.isClassOrInterface() && !ret.equals(mDesc.returnType())) {
 832                             // Explicit cast if method return type differs
 833                             cob.checkcast(ret);
 834                         }
 835                         push(op.result());
 836                     }
 837                     case FieldAccessOp.FieldLoadOp op -> {
 838                         processOperands(op);
 839                         FieldRef fd = op.fieldDescriptor();
 840                         if (op.operands().isEmpty()) {
 841                             cob.getstatic(
 842                                     ((JavaType) fd.refType()).toNominalDescriptor(),
 843                                     fd.name(),
 844                                     ((JavaType) fd.type()).toNominalDescriptor());
 845                         } else {
 846                             cob.getfield(
 847                                     ((JavaType) fd.refType()).toNominalDescriptor(),
 848                                     fd.name(),
 849                                     ((JavaType) fd.type()).toNominalDescriptor());
 850                         }
 851                         push(op.result());
 852                     }
 853                     case FieldAccessOp.FieldStoreOp op -> {
 854                         processOperands(op);
 855                         FieldRef fd = op.fieldDescriptor();
 856                         if (op.operands().size() == 1) {
 857                             cob.putstatic(
 858                                     ((JavaType) fd.refType()).toNominalDescriptor(),
 859                                     fd.name(),
 860                                     ((JavaType) fd.type()).toNominalDescriptor());
 861                         } else {
 862                             cob.putfield(
 863                                     ((JavaType) fd.refType()).toNominalDescriptor(),
 864                                     fd.name(),
 865                                     ((JavaType) fd.type()).toNominalDescriptor());
 866                         }
 867                     }
 868                     case InstanceOfOp op -> {
 869                         processFirstOperand(op);
 870                         cob.instanceOf(((JavaType) op.type()).toNominalDescriptor());
 871                         push(op.result());
 872                     }
 873                     case CastOp op -> {
 874                         processFirstOperand(op);
 875                         cob.checkcast(((JavaType) op.type()).toNominalDescriptor());
 876                         push(op.result());
 877                     }
 878                     case LambdaOp op -> {
 879                         JavaType intfType = (JavaType)op.functionalInterface();
 880                         MethodTypeDesc mtd = MethodRef.toNominalDescriptor(op.invokableType());
 881                         try {
 882                             Class<?> intfClass = (Class<?>)intfType.erasure().resolve(lookup);
 883                             processOperands(op.capturedValues());
 884                             ClassDesc[] captureTypes = op.capturedValues().stream()
 885                                     .map(Value::type).map(BytecodeGenerator::toClassDesc).toArray(ClassDesc[]::new);
 886                             int lambdaIndex = lambdaSink.size();
 887                             if (Quotable.class.isAssignableFrom(intfClass)) {
 888                                 cob.invokedynamic(DynamicCallSiteDesc.of(
 889                                         DMHD_LAMBDA_ALT_METAFACTORY,
 890                                         funcIntfMethodName(intfClass),
 891                                         MethodTypeDesc.of(intfType.toNominalDescriptor(),
 892                                                           captureTypes),
 893                                         mtd,
 894                                         MethodHandleDesc.ofMethod(DirectMethodHandleDesc.Kind.STATIC,
 895                                                                   className,
 896                                                                   "lambda$" + lambdaIndex,
 897                                                                   mtd.insertParameterTypes(0, captureTypes)),
 898                                         mtd,
 899                                         LambdaMetafactory.FLAG_QUOTABLE,
 900                                         MethodHandleDesc.ofMethod(DirectMethodHandleDesc.Kind.STATIC,
 901                                                 className,
 902                                                 "op$lambda$" + lambdaIndex,
 903                                                 OP_METHOD_DESC)));
 904                                 quotable.set(lambdaSink.size());
 905                             } else {
 906                                 cob.invokedynamic(DynamicCallSiteDesc.of(
 907                                         DMHD_LAMBDA_METAFACTORY,
 908                                         funcIntfMethodName(intfClass),
 909                                         MethodTypeDesc.of(intfType.toNominalDescriptor(), captureTypes),
 910                                         mtd,
 911                                         MethodHandleDesc.ofMethod(DirectMethodHandleDesc.Kind.STATIC,
 912                                                                   className,
 913                                                                   "lambda$" + lambdaIndex,
 914                                                                   mtd.insertParameterTypes(0, captureTypes)),
 915                                         mtd));
 916                             }
 917                             lambdaSink.add(op);
 918                         } catch (ReflectiveOperationException e) {
 919                             throw new IllegalArgumentException(e);
 920                         }
 921                         push(op.result());
 922                     }
 923                     case ConcatOp op -> {
 924                         processOperands(op);
 925                         cob.invokedynamic(DynamicCallSiteDesc.of(DMHD_STRING_CONCAT, MethodTypeDesc.of(CD_String,
 926                                 toClassDesc(op.operands().get(0).type()),
 927                                 toClassDesc(op.operands().get(1).type()))));
 928                         push(op.result());
 929                     }
 930                     case MonitorOp.MonitorEnterOp op -> {
 931                         processFirstOperand(op);
 932                         cob.monitorenter();
 933                     }
 934                     case MonitorOp.MonitorExitOp op -> {
 935                         processFirstOperand(op);
 936                         cob.monitorexit();
 937                     }
 938                     default ->
 939                         throw new UnsupportedOperationException("Unsupported operation: " + ops.get(i));
 940                 }
 941             }
 942             Op top = b.terminatingOp();
 943             switch (top) {
 944                 case ReturnOp op -> {
 945                     if (returnType != TypeKind.VOID) {
 946                         processFirstOperand(op);
 947                         // @@@ box, unbox, cast here ?
 948                     }
 949                     cob.return_(returnType);
 950                 }
 951                 case ThrowOp op -> {
 952                     processFirstOperand(op);
 953                     cob.athrow();
 954                 }
 955                 case BranchOp op -> {
 956                     setCatchStack(op.branch(), recentCatchBlocks);
 957 
 958                     assignBlockArguments(op.branch());
 959                     cob.goto_(getLabel(op.branch()));
 960                 }
 961                 case ConditionalBranchOp op -> {
 962                     setCatchStack(op.trueBranch(), recentCatchBlocks);
 963                     setCatchStack(op.falseBranch(), recentCatchBlocks);
 964 
 965                     if (getConditionForCondBrOp(op) instanceof BinaryTestOp btop) {
 966                         // Processing of the BinaryTestOp was deferred, so it can be merged with CondBrOp
 967                         conditionalBranch(prepareConditionalBranch(btop), op.trueBranch(), op.falseBranch());
 968                     } else {
 969                         processFirstOperand(op);
 970                         conditionalBranch(Opcode.IFEQ, op.trueBranch(), op.falseBranch());
 971                     }
 972                 }
 973                 case ExceptionRegionEnter op -> {
 974                     List<Block.Reference> enteringCatchBlocks = op.catchBlocks();
 975                     Block[] activeCatchBlocks = Arrays.copyOf(recentCatchBlocks, recentCatchBlocks.length + enteringCatchBlocks.size());
 976                     int i = recentCatchBlocks.length;
 977                     for (Block.Reference catchRef : enteringCatchBlocks) {
 978                         allCatchBlocks.set(catchRef.targetBlock().index());
 979                         activeCatchBlocks[i++] = catchRef.targetBlock();
 980                         setCatchStack(catchRef, recentCatchBlocks);
 981                     }
 982                     setCatchStack(op.start(), activeCatchBlocks);
 983 
 984                     assignBlockArguments(op.start());
 985                     cob.goto_(getLabel(op.start()));
 986                 }
 987                 case ExceptionRegionExit op -> {
 988                     List<Block.Reference> exitingCatchBlocks = op.catchBlocks();
 989                     Block[] activeCatchBlocks = Arrays.copyOf(recentCatchBlocks, recentCatchBlocks.length - exitingCatchBlocks.size());
 990                     setCatchStack(op.end(), activeCatchBlocks);
 991 
 992                     // Assert block exits in reverse order
 993                     int i = recentCatchBlocks.length;
 994                     for (Block.Reference catchRef : exitingCatchBlocks) {
 995                         assert catchRef.targetBlock() == recentCatchBlocks[--i];
 996                     }
 997 
 998                     assignBlockArguments(op.end());
 999                     cob.goto_(getLabel(op.end()));
1000                 }
1001                 default ->
1002                     throw new UnsupportedOperationException("Terminating operation not supported: " + top);
1003             }
1004         }
1005         exceptionRegionsChange(new Block[0]);
1006     }
1007 
1008     private void exceptionRegionsChange(Block[] newCatchBlocks) {
1009         if (!Arrays.equals(recentCatchBlocks, newCatchBlocks)) {
1010             int i = recentCatchBlocks.length - 1;
1011             Label currentLabel = cob.newBoundLabel();
1012             // Exit catch blocks missing in the newCatchBlocks
1013             while (i >=0 && (i >= newCatchBlocks.length || recentCatchBlocks[i] != newCatchBlocks[i])) {
1014                 Block catchBlock = recentCatchBlocks[i--];
1015                 List<Block.Parameter> params = catchBlock.parameters();
1016                 if (!params.isEmpty()) {
1017                     JavaType jt = (JavaType) params.get(0).type();
1018                     cob.exceptionCatch(tryStartLabels[catchBlock.index()], currentLabel, getLabel(catchBlock.index()), jt.toNominalDescriptor());
1019                 } else {
1020                     cob.exceptionCatchAll(tryStartLabels[catchBlock.index()], currentLabel, getLabel(catchBlock.index()));
1021                 }
1022                 tryStartLabels[catchBlock.index()] = null;
1023             }
1024             // Fill tryStartLabels for new entries
1025             while (++i < newCatchBlocks.length) {
1026                 tryStartLabels[newCatchBlocks[i].index()] = currentLabel;
1027             }
1028             recentCatchBlocks = newCatchBlocks;
1029         }
1030     }
1031 
1032     // Checks if the Op.Result is used more than once in operands and block arguments
1033     private static boolean moreThanOneUse(Value val) {
1034         return val.uses().stream().flatMap(u ->
1035                 Stream.concat(
1036                         u.op().operands().stream(),
1037                         u.op().successors().stream()
1038                                 .flatMap(r -> r.arguments().stream())))
1039                 .filter(val::equals).limit(2).count() > 1;
1040     }
1041 
1042     private void push(Value res) {
1043         assert oprOnStack == null;
1044         if (res.type().equals(JavaType.VOID)) return;
1045         if (isNextUse(res)) {
1046             if (moreThanOneUse(res)) {
1047                 switch (toTypeKind(res.type()).slotSize()) {
1048                     case 1 -> cob.dup();
1049                     case 2 -> cob.dup2();
1050                 }
1051                 storeIfUsed(res);
1052             }
1053             oprOnStack = res;
1054         } else {
1055             storeIfUsed(res);
1056             oprOnStack = null;
1057         }
1058     }
1059 
1060     // the rhs of any shift instruction must be int or smaller -> convert longs
1061     private void adjustRightTypeToInt(Op op) {
1062         TypeElement right = op.operands().getLast().type();
1063         if (right.equals(JavaType.LONG)) {
1064             cob.conversion(toTypeKind(right), TypeKind.INT);
1065         }
1066     }
1067 
1068     private static Op getConditionForCondBrOp(ConditionalBranchOp op) {
1069         Value p = op.predicate();
1070         if (p.uses().size() != 1) {
1071             return null;
1072         }
1073 
1074         if (p.declaringBlock() != op.ancestorBlock()) {
1075             return null;
1076         }
1077 
1078         // Check if used in successor
1079         for (Block.Reference s : op.successors()) {
1080             if (s.arguments().contains(p)) {
1081                 return null;
1082             }
1083         }
1084 
1085         if (p instanceof Op.Result or) {
1086             return or.op();
1087         } else {
1088             return null;
1089         }
1090     }
1091 
1092     private String funcIntfMethodName(Class<?> intfc) {
1093         String uniqueName = null;
1094         for (Method m : intfc.getMethods()) {
1095             // ensure it's SAM interface
1096             String methodName = m.getName();
1097             if (Modifier.isAbstract(m.getModifiers())
1098                     && (m.getReturnType() != String.class
1099                         || m.getParameterCount() != 0
1100                         || !methodName.equals("toString"))
1101                     && (m.getReturnType() != int.class
1102                         || m.getParameterCount() != 0
1103                         || !methodName.equals("hashCode"))
1104                     && (m.getReturnType() != boolean.class
1105                         || m.getParameterCount() != 1
1106                         || m.getParameterTypes()[0] != Object.class
1107                         || !methodName.equals("equals"))) {
1108                 if (uniqueName == null) {
1109                     uniqueName = methodName;
1110                 } else if (!uniqueName.equals(methodName)) {
1111                     // too many abstract methods
1112                     throw new IllegalArgumentException("Not a single-method interface: " + intfc.getName());
1113                 }
1114             }
1115         }
1116         if (uniqueName == null) {
1117             throw new IllegalArgumentException("No method in: " + intfc.getName());
1118         }
1119         return uniqueName;
1120     }
1121 
1122     private void conditionalBranch(Opcode reverseOpcode, Block.Reference trueBlock, Block.Reference falseBlock) {
1123         if (!needToAssignBlockArguments(falseBlock)) {
1124             cob.branch(reverseOpcode, getLabel(falseBlock));
1125         } else {
1126             cob.ifThen(reverseOpcode,
1127                 bb -> {
1128                     assignBlockArguments(falseBlock);
1129                     bb.goto_(getLabel(falseBlock));
1130                 });
1131         }
1132         assignBlockArguments(trueBlock);
1133         cob.goto_(getLabel(trueBlock));
1134     }
1135 
1136     private Opcode prepareConditionalBranch(BinaryTestOp op) {
1137         Value firstOperand = op.operands().get(0);
1138         TypeKind typeKind = toTypeKind(firstOperand.type());
1139         Value secondOperand = op.operands().get(1);
1140         processOperand(firstOperand);
1141         if (isZeroIntOrNullConstant(secondOperand)) {
1142             return switch (typeKind) {
1143                 case INT, BOOLEAN, BYTE, SHORT, CHAR ->
1144                     switch (op) {
1145                         case EqOp _ -> Opcode.IFNE;
1146                         case NeqOp _ -> Opcode.IFEQ;
1147                         case GtOp _ -> Opcode.IFLE;
1148                         case GeOp _ -> Opcode.IFLT;
1149                         case LtOp _ -> Opcode.IFGE;
1150                         case LeOp _ -> Opcode.IFGT;
1151                         default ->
1152                             throw new UnsupportedOperationException(op.opName() + " on int");
1153                     };
1154                 case REFERENCE ->
1155                     switch (op) {
1156                         case EqOp _ -> Opcode.IFNONNULL;
1157                         case NeqOp _ -> Opcode.IFNULL;
1158                         default ->
1159                             throw new UnsupportedOperationException(op.opName() + " on Object");
1160                     };
1161                 default ->
1162                     throw new UnsupportedOperationException(op.opName() + " on " + op.operands().get(0).type());
1163             };
1164         }
1165         processOperand(secondOperand);
1166         return switch (typeKind) {
1167             case INT, BOOLEAN, BYTE, SHORT, CHAR ->
1168                 switch (op) {
1169                     case EqOp _ -> Opcode.IF_ICMPNE;
1170                     case NeqOp _ -> Opcode.IF_ICMPEQ;
1171                     case GtOp _ -> Opcode.IF_ICMPLE;
1172                     case GeOp _ -> Opcode.IF_ICMPLT;
1173                     case LtOp _ -> Opcode.IF_ICMPGE;
1174                     case LeOp _ -> Opcode.IF_ICMPGT;
1175                     default ->
1176                         throw new UnsupportedOperationException(op.opName() + " on int");
1177                 };
1178             case REFERENCE ->
1179                 switch (op) {
1180                     case EqOp _ -> Opcode.IF_ACMPNE;
1181                     case NeqOp _ -> Opcode.IF_ACMPEQ;
1182                     default ->
1183                         throw new UnsupportedOperationException(op.opName() + " on Object");
1184                 };
1185             case FLOAT -> {
1186                 cob.fcmpg(); // FCMPL?
1187                 yield reverseIfOpcode(op);
1188             }
1189             case LONG -> {
1190                 cob.lcmp();
1191                 yield reverseIfOpcode(op);
1192             }
1193             case DOUBLE -> {
1194                 cob.dcmpg(); //CMPL?
1195                 yield reverseIfOpcode(op);
1196             }
1197             default ->
1198                 throw new UnsupportedOperationException(op.opName() + " on " + op.operands().get(0).type());
1199         };
1200     }
1201 
1202     private boolean isZeroIntOrNullConstant(Value v) {
1203         return v instanceof Op.Result or
1204                 && or.op() instanceof ConstantOp cop
1205                 && switch (cop.value()) {
1206                     case null -> true;
1207                     case Integer i -> i == 0;
1208                     case Boolean b -> !b;
1209                     case Byte b -> b == 0;
1210                     case Short s -> s == 0;
1211                     case Character ch -> ch == 0;
1212                     default -> false;
1213                 };
1214     }
1215 
1216     private static Opcode reverseIfOpcode(BinaryTestOp op) {
1217         return switch (op) {
1218             case EqOp _ -> Opcode.IFNE;
1219             case NeqOp _ -> Opcode.IFEQ;
1220             case GtOp _ -> Opcode.IFLE;
1221             case GeOp _ -> Opcode.IFLT;
1222             case LtOp _ -> Opcode.IFGE;
1223             case LeOp _ -> Opcode.IFGT;
1224             default ->
1225                 throw new UnsupportedOperationException(op.opName());
1226         };
1227     }
1228 
1229     private boolean needToAssignBlockArguments(Block.Reference ref) {
1230         List<Value> sargs = ref.arguments();
1231         List<Block.Parameter> bargs = ref.targetBlock().parameters();
1232         boolean need = false;
1233         for (int i = 0; i < bargs.size(); i++) {
1234             Block.Parameter barg = bargs.get(i);
1235             if (!barg.uses().isEmpty() && !barg.equals(sargs.get(i))) {
1236                 need = true;
1237                 allocateSlot(barg);
1238             }
1239         }
1240         return need;
1241     }
1242 
1243     private void assignBlockArguments(Block.Reference ref) {
1244         Block target = ref.targetBlock();
1245         List<Value> sargs = ref.arguments();
1246         if (allCatchBlocks.get(target.index())) {
1247             // Jumping to an exception handler, exception parameter is expected on stack
1248             Value value = sargs.getFirst();
1249             if (oprOnStack == value) {
1250                 oprOnStack = null;
1251             } else {
1252                 load(value);
1253             }
1254         } else if (target.predecessors().size() > 1) {
1255             List<Block.Parameter> bargs = target.parameters();
1256             // First push successor arguments on the stack, then pop and assign
1257             // so as not to overwrite slots that are reused slots at different argument positions
1258             for (int i = 0; i < bargs.size(); i++) {
1259                 Block.Parameter barg = bargs.get(i);
1260                 Value value = sargs.get(i);
1261                 if (!barg.uses().isEmpty() && !barg.equals(value)) {
1262                     if (oprOnStack == value) {
1263                         oprOnStack = null;
1264                     } else {
1265                         load(value);
1266                     }
1267                     storeIfUsed(barg);
1268                 }
1269             }
1270         } else {
1271             // Single-predecessor block can just map parameter slots
1272             List<Block.Parameter> bargs = ref.targetBlock().parameters();
1273             for (int i = 0; i < bargs.size(); i++) {
1274                 Value value = sargs.get(i);
1275                 if (oprOnStack == value) {
1276                     storeIfUsed(oprOnStack);
1277                     oprOnStack = null;
1278                 }
1279                 // Map slot of the block argument to slot of the value
1280                 singlePredecessorsValues.put(bargs.get(i), singlePredecessorsValues.getOrDefault(value, value));
1281             }
1282         }
1283     }
1284 }