Java Code Examples for org.objectweb.asm.Opcodes#INVOKEVIRTUAL

private void buildRecorderFromObject(
    int opcode, String owner, String name, String signature, boolean itf) {
  super.visitMethodInsn(opcode, owner, name, signature, itf);
  // -> stack: ... newobj
  super.visitInsn(Opcodes.DUP);
  // -> stack: ... newobj newobj
  super.visitInsn(Opcodes.DUP);
  // -> stack: ... newobj newobj newobj
  // We could be instantiating this class or a subclass, so we
  // have to get the class the hard way.
  super.visitMethodInsn(
      Opcodes.INVOKEVIRTUAL, "java/lang/Object", "getClass", "()Ljava/lang/Class;", false);
  // -> stack: ... newobj newobj Class
  super.visitInsn(Opcodes.SWAP);
  // -> stack: ... newobj Class newobj
  super.visitMethodInsn(
      Opcodes.INVOKESTATIC, recorderClass, recorderMethod, CLASS_RECORDER_SIG, false);
  // -> stack: ... newobj
}
 

@Override
public void visitMethodInsn(int opcode, String owner, String name, String descriptor,
    boolean isInterface) {
  if (!owner.equals(expectedOwner) || opcode != Opcodes.INVOKEVIRTUAL) {
    this.mv.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
    return;
  }

  Replacement replacement = REPLACEMENTS.get(name);
  if (replacement != null && replacement.descriptor.equals(descriptor)) {
    MutationIdentifier identifier = context.registerMutation(factory, replacement.toString());
    if (context.shouldMutate(identifier)) {
      this.mv.visitMethodInsn(
          opcode,
          owner,
          replacement.destinationName,
          replacement.descriptor,
          false);
      return;
    }
  }

  this.mv.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
}
 

static String normalizeInterfaceMethodName(String name, boolean isLambda, int opcode) {
  if (isLambda) {
    // Rename lambda method to reflect the new owner.  Not doing so confuses LambdaDesugaring
    // if it's run over this class again. LambdaDesugaring has already renamed the method from
    // its original name to include the interface name at this point.
    return name + DependencyCollector.INTERFACE_COMPANION_SUFFIX;
  }

  switch (opcode) {
    case Opcodes.INVOKESPECIAL:
      // Rename static methods holding default method implementations since their descriptor
      // differs from the original method (due to explicit receiver parameter). This avoids
      // possible clashes with static interface methods or generated stubs for default methods
      // that could otherwise have the same name and descriptor by coincidence.
      return name + DEFAULT_COMPANION_METHOD_SUFFIX;
    case Opcodes.INVOKESTATIC: // moved but with same name
      return name + "$$STATIC$$"; // TODO(b/117453106): Stop renaming static interface methods
    case Opcodes.INVOKEINTERFACE: // not moved
    case Opcodes.INVOKEVIRTUAL: // tolerate being called for non-interface methods
      return name;
    default:
      throw new IllegalArgumentException("Unexpected opcode calling " + name + ": " + opcode);
  }
}
 

private void pushClassNameOnStack() {
  super.visitInsn(Opcodes.DUP);
  // -> stack: ... class class
  super.visitMethodInsn(
      Opcodes.INVOKEVIRTUAL, "java/lang/Class", "getName", "()Ljava/lang/String;", false);
  // -> stack: ... class classNameDotted
}
 

/**
 * Convert code from using Class.X methods to our remapped versions
 */
public static byte[] transform(byte[] code) {
    ClassReader reader = new ClassReader(code); // Turn from bytes into visitor
    ClassNode node = new ClassNode();
    reader.accept(node, 0); // Visit using ClassNode

    for (MethodNode method : node.methods) { // Taken from SpecialSource
        ListIterator<AbstractInsnNode> insnIterator = method.instructions.iterator();
        while (insnIterator.hasNext()) {
            AbstractInsnNode insn = insnIterator.next();
            if (!(insn instanceof MethodInsnNode)) {
                continue;
            }
            MethodInsnNode mi = (MethodInsnNode) insn;
            switch (mi.getOpcode()) {
                case Opcodes.INVOKEVIRTUAL:
                    remapVirtual(mi);
                    break;
                case Opcodes.INVOKESTATIC:
                    remapForName(mi);
                    break;
            }
        }
    }

    ClassWriter writer = new ClassWriter(0);
    node.accept(writer);
    return writer.toByteArray();
}
 

@Override
public MethodNode generate() {
    int size = Bytecode.getArgsSize(this.argTypes) + this.returnType.getSize() + (this.targetIsStatic ? 0 : 1);
    MethodNode method = this.createMethod(size, size);
    if (!this.targetIsStatic) {
        method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
    }
    Bytecode.loadArgs(this.argTypes, method.instructions, this.targetIsStatic ? 0 : 1);
    boolean isPrivate = Bytecode.hasFlag(this.targetMethod, Opcodes.ACC_PRIVATE);
    int opcode = this.targetIsStatic ? Opcodes.INVOKESTATIC : (isPrivate ? Opcodes.INVOKESPECIAL : Opcodes.INVOKEVIRTUAL);
    method.instructions.add(new MethodInsnNode(opcode, this.info.getClassNode().name, this.targetMethod.name, this.targetMethod.desc, false));
    method.instructions.add(new InsnNode(this.returnType.getOpcode(Opcodes.IRETURN)));
    return method;
}
 

private static int resolveASMOpcode(CallType t) {
	switch (t) {
	case SPECIAL:
		return Opcodes.INVOKESPECIAL;
	case VIRTUAL:
		return Opcodes.INVOKEVIRTUAL;
	case INTERFACE:
		return Opcodes.INVOKEINTERFACE;
	default:
		throw new IllegalArgumentException(t.toString());
	}
}
 

protected void _call(int op, String owner, String name, String desc) {
	save_stack(false);
	int argLen = Type.getArgumentTypes(desc).length + (op == INVOKESTATIC ? 0 : 1);
	Expr[] args = new Expr[argLen];
	for (int i = args.length - 1; i >= 0; i--) {
		args[i] = pop();
	}
	InvocationExpr callExpr;
	switch(op) {
		case Opcodes.INVOKEVIRTUAL:
		case Opcodes.INVOKEINTERFACE:
		case Opcodes.INVOKESPECIAL:
			callExpr = new VirtualInvocationExpr(VirtualInvocationExpr.resolveCallType(op), args, owner, name, desc);
			break;
		case Opcodes.INVOKESTATIC:
			callExpr = new StaticInvocationExpr(args, owner, name, desc);
			break;
		default:
			throw new IllegalArgumentException("invalid call opcode " + op);
	}
	if(callExpr.getType() == Type.VOID_TYPE) {
		addStmt(new PopStmt(callExpr));
	} else {
		int index = currentStack.height();
		Type type = assign_stack(index, callExpr);
		push(load_stack(index, type));
	}
}
 

private void doVisitMethodInsn(
    final int opcode,
    final String owner,
    final String name,
    final String descriptor,
    final boolean isInterface) {
  checkVisitCodeCalled();
  checkVisitMaxsNotCalled();
  checkOpcodeMethod(opcode, Method.VISIT_METHOD_INSN);
  if (opcode != Opcodes.INVOKESPECIAL || !"<init>".equals(name)) {
    checkMethodIdentifier(version, name, "name");
  }
  checkInternalName(version, owner, "owner");
  checkMethodDescriptor(version, descriptor);
  if (opcode == Opcodes.INVOKEVIRTUAL && isInterface) {
    throw new IllegalArgumentException("INVOKEVIRTUAL can't be used with interfaces");
  }
  if (opcode == Opcodes.INVOKEINTERFACE && !isInterface) {
    throw new IllegalArgumentException("INVOKEINTERFACE can't be used with classes");
  }
  if (opcode == Opcodes.INVOKESPECIAL && isInterface && (version & 0xFFFF) < Opcodes.V1_8) {
    throw new IllegalArgumentException(
        "INVOKESPECIAL can't be used with interfaces prior to Java 8");
  }

  // Calling super.visitMethodInsn requires to call the correct version depending on this.api
  // (otherwise infinite loops can occur). To simplify and to make it easier to automatically
  // remove the backward compatibility code, we inline the code of the overridden method here.
  if (mv != null) {
    mv.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
  }
  ++insnCount;
}
 

public static boolean isCallOnContextAware(final AbstractInsnNode insn)
{
    Objects.requireNonNull(insn, "insn");
    if (insn.getOpcode() != Opcodes.INVOKEVIRTUAL
        && insn.getOpcode() != Opcodes.INVOKEINTERFACE)
        return false;
    final MethodInsnNode mi = (MethodInsnNode) insn;
    return isAssignableTo(mi.owner, ContextAware.class);
}
 

@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
	if (opcode == Opcodes.INVOKESPECIAL && UPDATED_METHODS.contains(name)) {
		opcode = Opcodes.INVOKEVIRTUAL;
	}
	super.visitMethodInsn(opcode, owner, name, desc, itf);
}
 

private boolean needsFrameGuard(int opcode, String owner, String name, String desc) {
    if (owner.startsWith("java/") || owner.startsWith("javax/")) {
        //System.out.println("SKIP:: " + owner + "." + name + desc);
        return false;
    }

    // Always create save-point before Continuation methods (like suspend)
    if (CONTINUATION_CLASS_INTERNAL_NAME.equals(owner)) {
        return CONTINUATION_CLASS_CONTINUABLE_METHODS.contains(name);
    }

    // No need to create save-point before constructors -- it's forbidden to suspend in constructors anyway
    if (opcode == Opcodes.INVOKESPECIAL && "<init>".equals(name)) {
        return false;
    }

    if (opcode == Opcodes.INVOKEINTERFACE ||
        opcode == Opcodes.INVOKESPECIAL   ||
        opcode == Opcodes.INVOKESTATIC    ||
        opcode == Opcodes.INVOKEVIRTUAL) {
        ContinuableClassInfo classInfo;
        try {
            classInfo = cciResolver.resolve(owner);
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
        return null != classInfo && classInfo.isContinuableMethod(opcode, name, desc, desc);
    }
    return false;
}
 

@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
  if (opcode == Opcodes.INVOKESPECIAL && name.startsWith("lambda$")) {
    opcode = itf ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL;
  }

  super.visitMethodInsn(opcode, owner, name, desc, itf);
}
 

@Override
public void visitMethodInsn(
    final int opcodeAndSource,
    final String owner,
    final String name,
    final String descriptor,
    final boolean isInterface) {
  if (api < Opcodes.ASM5 && (opcodeAndSource & Opcodes.SOURCE_DEPRECATED) == 0) {
    // Redirect the call to the deprecated version of this method.
    super.visitMethodInsn(opcodeAndSource, owner, name, descriptor, isInterface);
    return;
  }
  int opcode = opcodeAndSource & ~Opcodes.SOURCE_MASK;

  checkVisitCodeCalled();
  checkVisitMaxsNotCalled();
  checkOpcodeMethod(opcode, Method.VISIT_METHOD_INSN);
  if (opcode != Opcodes.INVOKESPECIAL || !"<init>".equals(name)) {
    checkMethodIdentifier(version, name, "name");
  }
  checkInternalName(version, owner, "owner");
  checkMethodDescriptor(version, descriptor);
  if (opcode == Opcodes.INVOKEVIRTUAL && isInterface) {
    throw new IllegalArgumentException("INVOKEVIRTUAL can't be used with interfaces");
  }
  if (opcode == Opcodes.INVOKEINTERFACE && !isInterface) {
    throw new IllegalArgumentException("INVOKEINTERFACE can't be used with classes");
  }
  if (opcode == Opcodes.INVOKESPECIAL && isInterface && (version & 0xFFFF) < Opcodes.V1_8) {
    throw new IllegalArgumentException(
        "INVOKESPECIAL can't be used with interfaces prior to Java 8");
  }
  super.visitMethodInsn(opcodeAndSource, owner, name, descriptor, isInterface);
  ++insnCount;
}
 

/**
 * Returns true if the mirror contains a method that mirrors
 * <code>methodName</code>. The mirror method should be static, have the
 * same name, and have the exact same arguments excepting an argument of
 * type
 */
public boolean hasMethod(final String owner, final String methodName, final String methodDescriptor, final int opcode) {
	Type[] types = Type.getArgumentTypes(methodDescriptor);

	if (opcode == Opcodes.INVOKEVIRTUAL || opcode == Opcodes.INVOKEINTERFACE) {
		Type[] newTypes = new Type[types.length + 1];
		newTypes[0] = Type.getType("L" + owner + ";");
		System.arraycopy(types, 0, newTypes, 1, types.length);
		types = newTypes;
	}

outer_loop:
	for (Method m : class_.getDeclaredMethods()) {
		final Type[] methodTypes = Type.getArgumentTypes(m);
		if (!m.getName().equals(methodName)
				|| methodTypes.length != types.length) {
			continue;
		}

		for (int i = 0; i < types.length; ++i) {
			if (!types[i].equals(methodTypes[i])) {
				continue outer_loop;
			}
		}

		return true;
	}

	return false;
}
 

@Override
public GambitCreator.Invocable createInvocable() {
    int op = Opcodes.INVOKEVIRTUAL;
    if (Modifier.isStatic(modifiers)) {
        op = Opcodes.INVOKESTATIC;
    }
    return ExactInvocation.exactInvoke(op, name, unit.getType(), getReturnType(), getArgumentTypes());
}
 

@Override
public void transform(ClassNode classNode, String name) {
    for (MethodNode methodNode : classNode.methods) { // Loop through all methods inside of the class.

        String methodName = methodNode.name;
        if (nameMatches(methodName, "showDurabilityBar")) { // always deobfuscated

            // Objective:
            // Find: return stack.isItemDamaged();
            // Replace With: return ItemHook.isItemDamaged(stack);

            Iterator<AbstractInsnNode> iterator = methodNode.instructions.iterator();
            while (iterator.hasNext()) {
                AbstractInsnNode abstractNode = iterator.next();
                if (abstractNode instanceof MethodInsnNode && abstractNode.getOpcode() == Opcodes.INVOKEVIRTUAL) {
                    MethodInsnNode methodInsnNode = (MethodInsnNode)abstractNode;
                    if (methodInsnNode.owner.equals(TransformerClass.ItemStack.getNameRaw()) && TransformerMethod.isItemDamaged.matches(methodInsnNode)) {
                        methodNode.instructions.insertBefore(abstractNode, new MethodInsnNode(Opcodes.INVOKESTATIC, "codes/biscuit/skyblockaddons/asm/hooks/ItemHook",
                                "isItemDamaged", "("+ TransformerClass.ItemStack.getName()+")Z", false)); // ItemHook.isItemDamaged(stack);

                        iterator.remove(); // Remove the old line.
                        break;
                    }
                }
            }
        }
        if (nameMatches(methodName, "getDurabilityForDisplay")) { // always deobfuscated

            // Objective:
            // Find: Method head.
            // Insert:   ReturnValue returnValue = new ReturnValue();
            //           ItemHook.getDurabilityForDisplay(stack, returnValue);
            //           if (returnValue.isCancelled()) {
            //               return returnValue.getValue();
            //           }

            methodNode.instructions.insertBefore(methodNode.instructions.getFirst(), insertDurabilityHook());
        }
    }
}
 

public boolean appendExpression(StringBuilder b) {
    // special case for clone on an array which isn't a real method invocation
    if(name.equals("clone") && owner.indexOf('[') > -1) {
        if (targetObjectLiteral != null) {
            b.append("cloneArray(").append(targetObjectLiteral).append(")");
        } else {
            b.append("cloneArray(POP_OBJ(1))");
        }
        return true;
    }
    
    StringBuilder bld = new StringBuilder();
    if(origOpcode == Opcodes.INVOKEINTERFACE || origOpcode == Opcodes.INVOKEVIRTUAL) {
        //b.append("    ");
        bld.append("virtual_");
    }
    
    if(origOpcode == Opcodes.INVOKESTATIC) {
        // find the actual class of the static method to workaround javac not defining it correctly
        ByteCodeClass bc = Parser.getClassObject(owner.replace('/', '_').replace('$', '_'));
        owner = findActualOwner(bc);
    }

    bld.append(owner.replace('/', '_').replace('$', '_'));
    bld.append("_");
    if(name.equals("<init>")) {
        bld.append("__INIT__");
    } else {
        if(name.equals("<clinit>")) {
            bld.append("__CLINIT__");
        } else {
            bld.append(name);
        }
    }
    bld.append("__");
    ArrayList<String> args = new ArrayList<String>();
    String returnVal = BytecodeMethod.appendMethodSignatureSuffixFromDesc(desc, bld, args);
    int numLiteralArgs = this.getNumLiteralArgs();
    if (numLiteralArgs > 0) {
        b.append("/* CustomInvoke */");
    }
    boolean noPop = false;
    b.append(bld);
    
    b.append("(threadStateData");
    
    
    
    if(origOpcode != Opcodes.INVOKESTATIC) {
        if (targetObjectLiteral == null) {
            //b.append(", SP[-");
            //b.append(args.size() + 1 - numLiteralArgs);
            //b.append("].data.o");
            return false;
        } else {
            b.append(", ").append(targetObjectLiteral);
            numLiteralArgs++;
        }
    }
    //int offset = args.size();
    //int numArgs = offset;
    int argIndex=0;
    for(String a : args) {
        
        b.append(", ");
        if (literalArgs != null && literalArgs[argIndex] != null) {
            b.append(literalArgs[argIndex]);
        } else {
            return false;
            //b.append("SP[-");
            //b.append(offset);
            //b.append("].data.");
            //b.append(a);
            //offset--;
        }
        argIndex++;
    }
    if (returnVal == null) {
        return false;
    }
    
    b.append(")");
    
    return true;
    
}
 

@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
    identityState = IdentityMethodState.NOT;
    methodCallCount++;
    if (isAccessMethod && this.accessOwner == null) {
        this.accessOwner = owner;
        this.accessName = name;
        this.accessDesc = desc;
        this.accessIsStatic = opcode == Opcodes.INVOKESTATIC;
        this.accessForField = false;
    }
    if (stubState == StubState.LOADED_STUB && opcode == Opcodes.INVOKESPECIAL
            && "java/lang/RuntimeException".equals(owner) && "<init>".equals(name)) {
        stubState = StubState.INITIALIZE_RUNTIME;
    } else {
        stubState = StubState.INITIAL;
    }
    if (owner.startsWith("java/util/concurrent")) {
        mBuilder.setUsesConcurrency();
    }
    if (opcode == Opcodes.INVOKEINTERFACE) {
        return;
    }

    if (owner.charAt(0) == '[' && owner.charAt(owner.length() - 1) != ';') {
        // primitive array
        return;
    }
    if (opcode == Opcodes.INVOKESTATIC && "java/lang/System".equals(owner) && "exit".equals(name)
            && !sawReturn) {
        sawSystemExit = true;
    }
    justSawInitializationOfUnsupportedOperationException = opcode == Opcodes.INVOKESPECIAL
            && "java/lang/UnsupportedOperationException".equals(owner) && "<init>".equals(name);

    if (isBridge && bridgedMethodSignature == null) {
        switch (opcode) {
        case Opcodes.INVOKEVIRTUAL:
        case Opcodes.INVOKESPECIAL:
        case Opcodes.INVOKESTATIC:
        case Opcodes.INVOKEINTERFACE:
            if (desc != null && name.equals(methodName)) {
                bridgedMethodSignature = desc;
            }
            break;
        default:
            break;
        }
    }

    // System.out.println("Call from " +
    // ClassParserUsingASM.this.slashedClassName +
    // " to " + owner + " : " + desc);
    if (desc == null || desc.indexOf('[') == -1 && desc.indexOf('L') == -1) {
        return;
    }
    if (ClassParserUsingASM.this.slashedClassName.equals(owner)) {
        return;
    }
    ClassDescriptor classDescriptor = DescriptorFactory.instance().getClassDescriptor(owner);
    calledClassSet.add(classDescriptor);

}
 

@Override
public void transform(ClassNode classNode, String name) {
    for (MethodNode methodNode : classNode.methods) {
        if (TransformerMethod.renderTileEntityAt.matches(methodNode)) {

            // Objective:
            // Find: this.bindTexture(ENDER_CHEST_TEXTURE);
            // Replacement: TileEntityEnderChestRendererHook.bindTexture(this, (ResourceLocation)ENDER_CHEST_TEXTURE);

            // Objective:
            // Find: this.field_147521_c.renderAll();
            // Insert 2 lines before: TileEntityEnderChestRendererHook.setEnderchestColor();

            int bindTextureCount = 0;

            Iterator<AbstractInsnNode> iterator = methodNode.instructions.iterator();

            while (iterator.hasNext()) {
                AbstractInsnNode abstractNode = iterator.next();

                if (abstractNode instanceof MethodInsnNode && abstractNode.getOpcode() == Opcodes.INVOKEVIRTUAL) {
                    MethodInsnNode methodInsnNode = (MethodInsnNode)abstractNode;
                    if (methodInsnNode.owner.equals(TransformerClass.TileEntityEnderChestRenderer.getNameRaw())
                            && TransformerMethod.bindTexture.matches(methodInsnNode)) { // TileEntityEnderChestRendererHook.bindTexture(ENDER_CHEST_TEXTURE);
                        if (bindTextureCount == 1) { // Find the second statement, not the first one.
                            methodNode.instructions.insertBefore(abstractNode, new MethodInsnNode(Opcodes.INVOKESTATIC, "codes/biscuit/skyblockaddons/asm/hooks/TileEntityEnderChestRendererHook",
                                    // Add TileEntityEnderChestRendererHook.bindTexture(this, (ResourceLocation)ENDER_CHEST_TEXTURE);
                                    "bindTexture", "("+TransformerClass.TileEntityEnderChestRenderer.getName()+TransformerClass.ResourceLocation.getName()+")V", false));
                            iterator.remove(); // Remove the old method call.
                        }
                        bindTextureCount++;
                    } else if (methodInsnNode.owner.equals(TransformerClass.ModelChest.getNameRaw())
                            && TransformerMethod.renderAll.matches(methodInsnNode)) { // The two lines are to make sure its before the "this" & the "field_147521_c".
                        methodNode.instructions.insertBefore(methodNode.instructions.get(methodNode.instructions.indexOf(abstractNode)-2), insertChangeEnderchestColor());
                    }
                }
            }
            break;
        }
    }
}