public void writeConditional(ExprStmtToken condition, LabelNode successLabel) { writeExpression(condition, true, false); writePopBoolean(); code.add(new JumpInsnNode(IFEQ, successLabel)); stackPop(); }
private static InsnList createNewIfThenElse(MethodInsnNode n) { LabelNode labelIsNotEmpty = new LabelNode(); LabelNode labelEndif = new LabelNode(); InsnList il = new InsnList(); il.add(n); il.add(new JumpInsnNode(Opcodes.IFLE, labelIsNotEmpty)); il.add(new InsnNode(Opcodes.ICONST_1)); il.add(new JumpInsnNode(Opcodes.GOTO, labelEndif)); il.add(labelIsNotEmpty); il.add(new InsnNode(Opcodes.ICONST_0)); il.add(labelEndif); return il; }
writePopBoolean(); LabelNode end = new LabelNode(); LabelNode next = new LabelNode(); code.add(new JumpInsnNode(IFEQ, next)); stackPop(); if (returnValue) { code.add(new JumpInsnNode(IFNE, next)); stackPop(); if (returnValue) { code.add(new JumpInsnNode(GOTO, end)); code.add(next);
newInstructions.add(new VarInsnNode(ALOAD, 1)); newInstructions.add(new MethodInsnNode(INVOKESTATIC, ASM_HOOKS, "entityRenderShadowAndFire", "(L" + CLASS_ENTITY + ";)Z", false)); newInstructions.add(new JumpInsnNode(IFNE, node1)); newInstructions.add(new InsnNode(RETURN)); methodNode -> { InsnList newInstructions = new InsnList(); LabelNode node1 = new LabelNode(); newInstructions.add(new VarInsnNode(ALOAD, 0)); newInstructions.add(new InsnNode(DUP)); newInstructions.add(new MethodInsnNode(INVOKEVIRTUAL, CLASS_EVENT, "isCanceled", "()Z", false)); newInstructions.add(new JumpInsnNode(IFEQ, node1)); newInstructions.add(new InsnNode(POP)); newInstructions.add(new InsnNode(RETURN)); newInstructions.add(new InsnNode(DUP)); newInstructions.add(new MethodInsnNode(INVOKEVIRTUAL, CLASS_EVENT, "isCanceled", "()Z", false)); newInstructions.add(new JumpInsnNode(IFEQ, node1)); newInstructions.add(new InsnNode(POP)); newInstructions.add(new InsnNode(RETURN));
InsnList toInject = new InsnList(); LabelNode ifNotCanceled = new LabelNode(); toInject.add(new VarInsnNode(Opcodes.ALOAD, 1)); toInject.add(new VarInsnNode(Opcodes.ALOAD, 2)); toInject.add(new VarInsnNode(Opcodes.ALOAD, 3)); toInject.add(new VarInsnNode(Opcodes.ILOAD, 4)); toInject.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(Hooks.class), "onFlowIntoBlock", "(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/state/IBlockState;I)Z", false)); toInject.add(new JumpInsnNode(Opcodes.IFEQ, ifNotCanceled)); toInject.add(new InsnNode(Opcodes.RETURN)); toInject.add(ifNotCanceled); LabelNode varStartLabel = new LabelNode(); LocalVariableNode localVar = new LocalVariableNode("isBlockFullCube", "I", method.signature, varStartLabel, end, method.maxLocals); method.maxLocals++; toInject.add(new VarInsnNode(ISTORE, localVar.index)); // isBlockFullCube = Hooks.isBlockFullCube(...) toInject.add(varStartLabel); // variable scope start LabelNode label = new LabelNode(); // label if condition is true toInject.add(new VarInsnNode(ILOAD, localVar.index)); // isBlockFullCube toInject.add(new InsnNode(ICONST_M1)); // -1 toInject.add(new JumpInsnNode(IF_ICMPEQ, label)); // isBlockFullCube != -1 LabelNode labelReturnIf = new LabelNode(); // label if second condition is true toInject.add(new VarInsnNode(ILOAD, localVar.index)); // isBlockFullCube toInject.add(new JumpInsnNode(IFEQ, labelReturnIf)); // isBlockFullCube != 0 toInject.add(new InsnNode(ICONST_1)); // 1 (true) toInject.add(new InsnNode(IRETURN)); // return true;
private void writeBody(IfStmtToken token) { LabelNode end = new LabelNode(); LabelNode elseL = new LabelNode(); expr.writePopBoolean(); add(new JumpInsnNode(IFEQ, token.getElseBody() != null ? elseL : end)); expr.stackPop(); if (token.getBody() != null) { expr.write(token.getBody()); } if (token.getElseBody() != null){ add(new JumpInsnNode(GOTO, end)); add(elseL); expr.write(token.getElseBody()); } add(end); add(new LineNumberNode(token.getMeta().getEndLine(), end)); }
Objects.requireNonNull(method, "method"); AbstractInsnNode current = method.instructions.getLast(); final LabelNode lastReturnLabel = new LabelNode(); method.instructions.insertBefore(current, lastReturnLabel); continue; final JumpInsnNode insn = new JumpInsnNode(GOTO, lastReturnLabel); method.instructions.set(current, insn); current = insn;
HashSet<Label> labels = new HashSet<Label>(); for (TryCatchBlockNode catchNode : (List<TryCatchBlockNode>) m.tryCatchBlocks) { if (labels.contains(catchNode.handler.getLabel())) { labels.add(catchNode.handler.getLabel()); AbstractInsnNode lineNumberNode = labelNode.getNext() instanceof LineNumberNode ? labelNode.getNext() : labelNode; FrameNode frameNode = (FrameNode) lineNumberNode.getNext(); VarInsnNode varInsnNode = (VarInsnNode) frameNode.getNext(); LabelNode labelNode4ifeg = new LabelNode(); InsnList newCode = new InsnList(); newCode.add(new VarInsnNode(Opcodes.ALOAD, varInsnNode.var)); newCode.add(new TypeInsnNode(Opcodes.INSTANCEOF, INTERRUPT_EXCEPTION_NAME)); newCode.add(new JumpInsnNode(Opcodes.IFEQ, labelNode4ifeg)); newCode.add(new VarInsnNode(Opcodes.ALOAD, varInsnNode.var)); newCode.add(new TypeInsnNode(Opcodes.CHECKCAST, INTERRUPT_EXCEPTION_NAME));
@Override protected AbstractInsnNode transformJumpInsnNode(MethodNode mn, JumpInsnNode jumpNode) { if (jumpNode.getOpcode() == Opcodes.IFNE) { if (this.booleanTestabilityTransformation.isBooleanOnStack(mn, jumpNode, 0)) { TransformationStatistics.transformedBooleanComparison(); BooleanTestabilityTransformation.logger.info("Changing IFNE"); jumpNode.setOpcode(Opcodes.IFGT); } else { BooleanTestabilityTransformation.logger.info("Not changing IFNE"); int insnPosition = mn.instructions.indexOf(jumpNode); Frame frame = this.booleanTestabilityTransformation.currentFrames[insnPosition]; AbstractInsnNode insn = mn.instructions.get(insnPosition - 1); BooleanTestabilityTransformation.logger.info("Current node: " + mn.instructions.get(insnPosition)); BooleanTestabilityTransformation.logger.info("Previous node: " + insn); if (insn instanceof MethodInsnNode) { mi.desc)) == Type.BOOLEAN_TYPE) { BooleanTestabilityTransformation.logger.info("Changing IFNE"); jumpNode.setOpcode(Opcodes.IFGT); } else if (jumpNode.getOpcode() == Opcodes.IFEQ) { if (this.booleanTestabilityTransformation.isBooleanOnStack(mn, jumpNode, 0)) { TransformationStatistics.transformedBooleanComparison(); BooleanTestabilityTransformation.logger.info("Changing IFEQ"); jumpNode.setOpcode(Opcodes.IFLE); } else { BooleanTestabilityTransformation.logger.info("Not changing IFEQ"); if (Type.getReturnType(BooleanTestabilityTransformation.getOriginalDesc(mi.owner, mi.name, mi.desc)) == Type.BOOLEAN_TYPE) {
final LabelNode l0 = new LabelNode(); final LabelNode l1 = new LabelNode(); final LabelNode l2 = new LabelNode(); ListIterator<AbstractInsnNode> iter = methodNode.instructions.iterator(); wInstructions.add(ins); wInstructions.add(new InsnNode(Opcodes.ACONST_NULL)); wInstructions.add(new VarInsnNode(Opcodes.ASTORE, varReturnValue)); wInstructions.add(new JumpInsnNode(Opcodes.GOTO, l2));
for (Integer op : getOperators(node.getOpcode(), isBoolean)) { logger.debug("Adding replacement " + op); if (op >= 0) { JumpInsnNode mutation = new JumpInsnNode(op, target); + getOp(node.getOpcode()) + " -> " + getOp(op), instruction, mutation, getInfectionDistance(node.getOpcode(), op)); mutations.add(mutationObject); InsnList mutation = new InsnList(); if (opcodesInt.contains(node.getOpcode())) mutation.add(new InsnNode(Opcodes.POP)); else mutation.add(new InsnNode(Opcodes.POP2)); mutation.add(new JumpInsnNode(Opcodes.IFNE, target)); Mutation mutationObject = MutationPool.addMutation(className, methodName, NAME + " " + getOp(node.getOpcode()) + " -> " + op, instruction, mutation,
private InsnList _goto(Label label) { InsnList il = new InsnList(); if (!isSub() || resolver.isLocalLabel(label)) { il.add(new JumpInsnNode(GOTO, l(label))); } else { il.add(_nonLocalGoto(label)); } return il; }
LabelNode lb = new LabelNode(); LabelNode escapeNode = new LabelNode(); AbstractInsnNode target = methodNode.instructions.getFirst(); methodNode.instructions.insertBefore(target, new JumpInsnNode(GOTO, escapeNode)); methodNode.instructions.insertBefore(target, lb); Type returnType = Type.getReturnType(methodNode.desc); switch (returnType.getSort()) {
JumpInsnNode jumpInsn = (JumpInsnNode) nextNextInsn; boolean doJump = false; switch (jumpInsn.getOpcode()) { case Opcodes.IFEQ: if (isFloatValue(value)) { method.instructions.set(insn, new JumpInsnNode(Opcodes.GOTO, jumpInsn.label)); } else { method.instructions.remove(insn); deleteUpToInsn = jumpInsn.getNext();
void changeLastInsnToGOTO(LabelNode label) { setInstruction(endPos, new JumpInsnNode(GOTO, label)); }
@Override public AbstractInsnNode clone(final Map<LabelNode, LabelNode> clonedLabels) { return new JumpInsnNode(opcode, clone(label, clonedLabels)).cloneAnnotations(this); } }
for (ListIterator<?> lit = method.instructions.iterator(); lit.hasNext(); ) { AbstractInsnNode insn = (AbstractInsnNode) lit.next(); if (insn.getType() == JUMP_INSN) { if (jumpInsn.getOpcode() == Opcodes.GOTO) { AbstractInsnNode next = jumpInsn.getNext(); while (next != null) { if (next == label) { } else { if (jumpInsn.getOpcode() == Opcodes.GOTO && target != null) { switch (target.getOpcode()) { case Opcodes.IRETURN: case Opcodes.ATHROW: method.instructions.set(insn, target.clone(null));
@Override public void accept(final MethodVisitor methodVisitor) { methodVisitor.visitJumpInsn(opcode, label.getLabel()); acceptAnnotations(methodVisitor); }
/** {@inheritDoc} */ @Override public List<Mutation> apply(MethodNode mn, String className, String methodName, BytecodeInstruction instruction, Frame frame) { List<Mutation> mutations = new LinkedList<Mutation>(); JumpInsnNode node = (JumpInsnNode) instruction.getASMNode(); LabelNode target = node.label; // insert mutation into bytecode with conditional JumpInsnNode mutation = new JumpInsnNode(getOpposite(node.getOpcode()), target); // insert mutation into pool Mutation mutationObject = MutationPool.addMutation(className, methodName, NAME, instruction, mutation, Mutation.getDefaultInfectionDistance()); mutations.add(mutationObject); return mutations; }