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

@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
  if (itf && opcode == Opcodes.INVOKESTATIC) {
    checkNotNull(bootclasspathReader);
    checkState(
        bootclasspathReader.isKnown(owner),
        "%s contains invocation of static interface method that is "
            + "not in the bootclasspath. Owner: %s, name: %s, desc: %s.",
        Java7Compatibility.this.internalName,
        owner,
        name,
        desc);
    if (!updated) {
      Java7Compatibility.this.cv.visit(
          Opcodes.V1_8,
          Java7Compatibility.this.access,
          Java7Compatibility.this.internalName,
          Java7Compatibility.this.signature,
          Java7Compatibility.this.superName,
          Java7Compatibility.this.interfaces);
      updated = true;
    }
  }
  super.visitMethodInsn(opcode, owner, name, desc, itf);
}
 

@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
  if (opcode == Opcodes.INVOKESTATIC
      && "$jacocoInit".equals(name)
      && internalName.equals(owner)) {
    checkNotNull(factory);
    ClassReader bytecode =
        checkNotNull(
            factory.readIfKnown(internalName),
            "Couldn't load interface %s to inline $jacocoInit()",
            internalName);
    InlineOneMethod copier = new InlineOneMethod("$jacocoInit", this);
    bytecode.accept(copier, ClassReader.SKIP_DEBUG /* we're copying generated code anyway */);
  } else {
    super.visitMethodInsn(opcode, owner, name, desc, itf);
  }
}
 

private void invokeRecordAllocation(String typeName) {
  Matcher matcher = namePattern.matcher(typeName);
  if (matcher.find()) {
    typeName = matcher.group(1);
  }
  // stack: ... count newobj
  super.visitInsn(Opcodes.DUP_X1);
  // -> stack: ... newobj count newobj
  super.visitLdcInsn(typeName);
  // -> stack: ... newobj count newobj typename
  super.visitInsn(Opcodes.SWAP);
  // -> stack: ... newobj count typename newobj
  super.visitMethodInsn(
      Opcodes.INVOKESTATIC, recorderClass, recorderMethod, RECORDER_SIGNATURE, false);
  // -> stack: ... newobj
}
 

private void doVisitMethodInsn(
    final int opcode,
    final String owner,
    final String name,
    final String descriptor,
    final boolean isInterface) {
  switch (opcode) {
    case Opcodes.INVOKESPECIAL:
      invokespecial(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKEVIRTUAL:
      invokevirtual(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKESTATIC:
      invokestatic(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKEINTERFACE:
      invokeinterface(owner, name, descriptor);
      break;
    default:
      throw new IllegalArgumentException();
  }
}
 

/**
 * Common state machine advancing call.  Called at every instruction to see if we need to inject and/or advance
 * the state machine.
 */
private void checkInject() {
    if (this.scanningToNewBlockStart) {
        // We were waiting for this so make sure that this block has some associated cost.
        BasicBlock currentBlock = this.blocks.get(this.nextBlockIndexToWrite);
        long currentEnergyCost = currentBlock.getEnergyCost();
        // We should never encounter a block with a zero/negative cost.
        RuntimeAssertionError.assertTrue(currentEnergyCost > 0L);
        // We track this as a long but report it as an int so prove that this can't overflow.
        RuntimeAssertionError.assertTrue(currentEnergyCost <= (long)Integer.MAX_VALUE);
        
        // Inject the bytecodes.
        super.visitLdcInsn(Integer.valueOf((int)currentEnergyCost));
        super.visitMethodInsn(Opcodes.INVOKESTATIC, Helper.RUNTIME_HELPER_NAME, "chargeEnergy", "(I)V", false);
        
        // Reset the state machine for the next block.
        this.scanningToNewBlockStart = false;
        this.nextBlockIndexToWrite += 1;
    }
}
 

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

            // Objective:
            // Find: Mouse.setCursorPosition(MouseHelperHook.ungrabMouseCursor() / 2, Display.getHeight() / 2);
            // Replace method with: MouseHelperHook.ungrabMouseCursor(Display.getWidth() / 2, Display.getHeight() / 2);

            Iterator<AbstractInsnNode> iterator = methodNode.instructions.iterator();
            while (iterator.hasNext()) {
                AbstractInsnNode abstractNode = iterator.next();
                if (abstractNode instanceof MethodInsnNode && abstractNode.getOpcode() == Opcodes.INVOKESTATIC) {
                    MethodInsnNode methodInsnNode = (MethodInsnNode)abstractNode;
                    if (methodInsnNode.owner.equals("org/lwjgl/input/Mouse") && methodInsnNode.name.equals("setCursorPosition")) { // these are not minecraft methods, not obfuscated

                        methodNode.instructions.insertBefore(abstractNode, new MethodInsnNode(Opcodes.INVOKESTATIC, "codes/biscuit/skyblockaddons/asm/hooks/MouseHelperHook",
                                "ungrabMouseCursor", "(II)V", false)); // Add the replacement method call.
                        iterator.remove(); // Remove the old method call.
                        break;
                    }
                }
            }
            break;
        }
    }
}
 

private void addLog(boolean dup, int site) {
	if (dup)
		super.visitInsn(Opcodes.DUP);
	super.visitLdcInsn(new Integer(site));
	super.visitMethodInsn(Opcodes.INVOKESTATIC, name,
			LOG_INTERNAL_ALLOC_REPORT, OBJECT_SITE_SIGNATURE);
	if (!constructor)
		super.visitMethodInsn(Opcodes.INVOKESTATIC, name,
				LOG_INTERNAL_ALLOC_DONE, VOID_SIGNATURE);
}
 

public static boolean isBooleanValueOfZ(final AbstractInsnNode insn)
{
    Objects.requireNonNull(insn, "insn");
    if (insn.getOpcode() != Opcodes.INVOKESTATIC)
        return false;
    final MethodInsnNode mi = (MethodInsnNode) insn;
    return isBooleanValueOfZ(mi.owner, mi.name, mi.desc);
}
 

private void doVisitMethodInsn(
    final int opcode,
    final String owner,
    final String name,
    final String descriptor,
    final boolean isInterface) {
  if (mv != null) {
    mv.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
  }
  if (this.locals == null) {
    labels = null;
    return;
  }
  pop(descriptor);
  if (opcode != Opcodes.INVOKESTATIC) {
    Object value = pop();
    if (opcode == Opcodes.INVOKESPECIAL && name.equals("<init>")) {
      Object initializedValue;
      if (value == Opcodes.UNINITIALIZED_THIS) {
        initializedValue = this.owner;
      } else {
        initializedValue = uninitializedTypes.get(value);
      }
      for (int i = 0; i < locals.size(); ++i) {
        if (locals.get(i) == value) {
          locals.set(i, initializedValue);
        }
      }
      for (int i = 0; i < stack.size(); ++i) {
        if (stack.get(i) == value) {
          stack.set(i, initializedValue);
        }
      }
    }
  }
  pushDescriptor(descriptor);
  labels = null;
}
 

protected void onMethodEnter() {
	if (done || ! isSynchronized()) return;
	
	has_monitor_operation = true;
	super.visitInsn(Opcodes.ACONST_NULL);
	super.pop();
	methodStartLabel = super.mark();

	super.visitMethodInsn(Opcodes.INVOKESTATIC, className, LOG_INTERNAL_ENTER_METHOD, LOG_CLASS_SIGNATURE);
}
 

public void visitMethodInsn(int opcode, String owner, String methodName, String desc) {
	if ((JAVA_LANG_RUNTIME.equals(owner) || (inherit && name.equals(owner))) &&
		RUNTIME_METHOD_NAME.equals(methodName) &&
		RUNTIME_SIGNATURE.equals(desc)) {
		found = true;
		super.visitMethodInsn(Opcodes.INVOKESTATIC,name,RUNTIME_INTERNAL_METHOD_NAME,RUNTIME_INTERNAL_SIGNATURE);
	} else {
		super.visitMethodInsn(opcode,owner,methodName,desc);
	}
}
 

@Override
public BytecodeExpression getPropertyNameIterable(BytecodeExpression target) {
    return new InvokeExpression(MapPropertyAdapter.class,
            Opcodes.INVOKESTATIC,
            "stringsOnly",
            Type.getMethodDescriptor(Type.getType(Iterable.class), Type.getType(Iterable.class)),
            new IterableTypeWidget(BaseTypeAdapter.STRING),
            null,
            ImmutableList.<BytecodeExpression>of(new InvokeExpression(Map.class,
            "keySet",
            new SetTypeWidget(keyType),
            target,
            ImmutableList.<BytecodeExpression>of())));
}
 

private static void insertTextureHandler(ClassNode node, boolean isObfuscated)
{
    // We're attempting to turn this line from GlStateManager.bindTexture:
    //      GL11.glBindTexture(GL11.GL_TEXTURE_2D, texture);
    // into this:
    //      TextureHelper.glBindTexture(GL11.GL_TEXTURE_2D, texture);
    // TextureHelpers's method then decides whether or not add a shader to the OpenGL pipeline before
    // passing the call on to GL11.glBindTexture.

    final String methodName = isObfuscated ? "func_179144_i" : "bindTexture";
    final String methodDescriptor = "(I)V"; // Takes one int, returns void.

    System.out.println("MALMO: Found GlStateManager, attempting to transform it");

    for (MethodNode method : node.methods)
    {
        if (method.name.equals(methodName) && method.desc.equals(methodDescriptor))
        {
            System.out.println("MALMO: Found GlStateManager.bindTexture() method, attempting to transform it");
            for (AbstractInsnNode instruction : method.instructions.toArray())
            {
                if (instruction.getOpcode() == Opcodes.INVOKESTATIC)
                {
                    MethodInsnNode visitMethodNode = (MethodInsnNode)instruction;
                    if (visitMethodNode.name.equals("glBindTexture"))
                    {
                        visitMethodNode.owner = "com/microsoft/Malmo/Utils/TextureHelper";
                        if (isObfuscated)
                        {
                            visitMethodNode.name = "bindTexture";
                        }
                        System.out.println("MALMO: Hooked into call to GlStateManager.bindTexture()");
                    }
                }
            }
        }
    }
}
 

RedirectedInvokeData(Target target, MethodInsnNode node) {
    super(target);
    this.node = node;
    this.returnType = Type.getReturnType(node.desc);
    this.targetArgs = Type.getArgumentTypes(node.desc);
    this.handlerArgs = node.getOpcode() == Opcodes.INVOKESTATIC
            ? this.targetArgs
            : ObjectArrays.concat(Type.getObjectType(node.owner), this.targetArgs);
}
 

@Override
public void visitMethodInsn(
    int opcode, String owner, String name, String descriptor, boolean isInterface) {
  if (opcode == Opcodes.INVOKESTATIC && owner.equals(SRC_OWNER)) {
    if (REWRITE_MAP.containsKey(Arrays.asList(owner, name, descriptor))) {
      matches.add(new StackTraceElement(className, methodName, fileName, lineNumber));
    }
  }
  super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
}
 

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;
}
 

public static AbstractInsnNode methodCall(ClassNode classNode, MethodNode methodNode) {
    int opcode = Opcodes.INVOKEVIRTUAL;

    if (Modifier.isInterface(classNode.access)) {
        opcode = Opcodes.INVOKEINTERFACE;
    }
    if (Modifier.isStatic(methodNode.access)) {
        opcode = Opcodes.INVOKESTATIC;
    }
    if (methodNode.name.startsWith("<")) {
        opcode = Opcodes.INVOKESPECIAL;
    }

    return new MethodInsnNode(opcode, classNode.name, methodNode.name, methodNode.desc, false);
}
 

public static MethodInsnNode getWrapperContructionInst(Type type) {

        char charType = type.getDescriptor().charAt(0);
        String wrapper;
        switch (charType) {
            case 'B':
                wrapper = "java/lang/Byte";
                break;
            case 'C':
                wrapper = "java/lang/Character";
                break;
            case 'D':
                wrapper = "java/lang/Double";
                break;
            case 'F':
                wrapper = "java/lang/Float";
                break;
            case 'I':
                wrapper = "java/lang/Integer";
                break;
            case 'J':
                wrapper = "java/lang/Long";
                break;
            case 'L':
                return null;
            case '[':
                return null;
            case 'Z':
                wrapper = "java/lang/Boolean";
                break;
            case 'S':
                wrapper = "java/lang/Short";
                break;
            default:
                throw new ClassFormatError("Invalid method signature: "
                        + type.getDescriptor());
        }

        return new MethodInsnNode(Opcodes.INVOKESTATIC, wrapper, "valueOf",
                "(" + charType + ")L" + wrapper + ";", false);

    }
 

/**
 * @param opcode
 * @param args
 * @param tgt
 * @param r
 * @param signatureTypes
 * @return
 */
private List<Type> setupTainting ( MethodReference call, int opcode, List<BaseType> args, Object tgt, MethodReference r, Type[] signatureTypes ) {
    if ( opcode != Opcodes.INVOKESTATIC && opcode != Opcodes.INVOKEDYNAMIC ) {
        if ( tgt == null || ! ( tgt instanceof BaseType ) || ( (BaseType) tgt ).isTainted() ) {
            r.taintCallee();
        }
    }

    boolean foundTypes = true;
    List<Type> actualTypes = new ArrayList<>();
    if ( signatureTypes.length != args.size() ) {
        return null;
    }
    for ( int i = 0; i < signatureTypes.length; i++ ) {
        Object object = args.get(i);
        if ( object instanceof BaseType ) {
            if ( object instanceof SimpleType ) {
                Type type = ( (SimpleType) object ).getType();
                Set<Type> altTypes = ( (BaseType) object ).getAlternativeTypes();

                Type sigType = signatureTypes[ i ];
                if ( type == null ) {
                    actualTypes.add(sigType);
                }
                else if ( altTypes == null || altTypes.isEmpty() ) {
                    try {
                        Type moreConcreteType = this.parent.getAnalyzer().getMoreConcreteType(type, sigType);
                        if ( !moreConcreteType.equals(sigType) ) {
                            // log.info("Improving type to " + moreConcreteType + " for " + call + " in " +
                            // this.ref);
                        }
                        actualTypes.add(moreConcreteType);
                    }
                    catch ( SerianalyzerException e ) {
                        this.log.error("Failed to determine argument type", e); //$NON-NLS-1$
                        this.log.warn("Formal arguments are " + Arrays.toString(signatureTypes)); //$NON-NLS-1$
                        this.log.warn("Known arguments are " + args); //$NON-NLS-1$
                        this.log.warn("Failing arg " + i + ": " + object); //$NON-NLS-1$ //$NON-NLS-2$
                        this.log.warn("Failing arg type " + type); //$NON-NLS-1$
                        this.log.warn("Signature type " + sigType); //$NON-NLS-1$
                        this.log.warn("In " + this.ref); //$NON-NLS-1$
                        this.log.warn("Calling " + call); //$NON-NLS-1$
                        foundTypes = false;
                    }
                }
            }
            else {
                foundTypes = false;
            }

            if ( ( (BaseType) object ).isTainted() ) {
                r.taintParameter(i);
            }

            if ( object instanceof BasicVariable && ( (BasicVariable) object ).isTaintReturns() ) {
                r.taintParameterReturns(i);
            }
        }
        else {
            r.taintParameter(i);
            foundTypes = false;
        }
    }

    if ( foundTypes ) {
        return actualTypes;
    }

    //
    return null;
}
 

public MethodInsnNode() {
  super(Opcodes.INVOKESTATIC);
  owner = "";
  desc = "";
  name = "";
}