Example usage for org.objectweb.asm Handle getDesc

List of usage examples for org.objectweb.asm Handle getDesc

  1. HOME
  2. Java
  3. org.objectweb.asm
  4. org.objectweb.asm.*
  5. Handle
  6. getDesc

Introduction

In this page you can find the example usage for org.objectweb.asm Handle getDesc.

Prototype

public String getDesc()

Source Link

Document

Returns the descriptor of the field or method designated by this handle.

Usage

From source file:ch.eiafr.cojac.FloatReplacerMethodVisitor.java

License:Apache License

@Override
public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) {
    if (!bsm.getOwner().equals("java/lang/invoke/LambdaMetafactory")) {
        mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs);
        return; // TODO: handle any bootstrap method in invokedynamic
    }/*  w w w .  j a va 2  s . c  o m*/
    if (!(bsmArgs[0] instanceof Type) || !(bsmArgs[1] instanceof Handle) || !(bsmArgs[2] instanceof Type)) {
        mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs);
        return;
    }
    Type a0 = (Type) (bsmArgs[0]);
    Type a2 = (Type) (bsmArgs[2]);
    Handle target = (Handle) (bsmArgs[1]);
    String handleOwner = target.getOwner();
    if (!references.hasToBeInstrumented(handleOwner)) {
        mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs);
        return;
    }
    Object[] bsmArgsAfter = new Object[bsmArgs.length];
    for (int i = 0; i < bsmArgs.length; i++) {
        bsmArgsAfter[i] = bsmArgs[i];
    }
    String a0Before = a0.getInternalName(), a2Before = a2.getInternalName();
    String a0After = replaceFloatMethodDescription(a0Before), a2After = replaceFloatMethodDescription(a2Before);
    bsmArgsAfter[0] = Type.getType(a0After);
    bsmArgsAfter[2] = Type.getType(a2After);
    bsmArgsAfter[1] = new Handle(target.getTag(), target.getOwner(), target.getName(),
            replaceFloatMethodDescription(target.getDesc()));
    mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgsAfter);
}

From source file:com.devexperts.usages.ClassUsagesAnalyzer.java

License:Open Source License

private void markHandleUse(Handle handle, Member usedFrom, UseKind useKind) {
    markTypeUse(Type.getType(handle.getDesc()), usedFrom, useKind);
    String className = Type.getType(handle.getOwner()).getClassName();
    switch (handle.getTag()) {
    case Opcodes.H_GETFIELD:
    case Opcodes.H_GETSTATIC:
    case Opcodes.H_PUTFIELD:
    case Opcodes.H_PUTSTATIC:
        markMemberUse(className, handle.getName(), usedFrom, useKind);
        break;//  w w w.  java 2 s. c  o  m
    case Opcodes.H_INVOKEVIRTUAL:
    case Opcodes.H_INVOKESTATIC:
    case Opcodes.H_INVOKESPECIAL:
    case Opcodes.H_NEWINVOKESPECIAL:
    case Opcodes.H_INVOKEINTERFACE:
        markMemberUse(className, Member.methodMemberName(handle.getName(), Type.getType(handle.getDesc())),
                usedFrom, useKind);
    }
}

From source file:com.geeksaga.light.profiler.util.ConstantPoolWrapper.java

License:Apache License

public Constant newConst(final Object cst, boolean isExtend) {
    if (cst instanceof Integer) {
        int val = (Integer) cst;
        return newInteger(val, isExtend);
    } else if (cst instanceof Float) {
        float val = (Float) cst;
        return newFloat(val, isExtend);
    } else if (cst instanceof Long) {
        long val = (Long) cst;
        return newLong(val, isExtend);
    } else if (cst instanceof Double) {
        double val = (Double) cst;
        return newDouble(val, isExtend);
    } else if (cst instanceof String) {
        return newString((String) cst);
    } else if (cst instanceof Type) {
        Type t = (Type) cst;
        int s = t.getSort();
        if (s == Type.OBJECT) {
            return newClass(t.getInternalName(), isExtend);
        } else if (s == Type.METHOD) {
            return newMethodType(t.getDescriptor(), isExtend);
        } else {//from   w ww. j av a  2  s. c o m
            return newClass(t.getDescriptor(), isExtend);
        }
    } else if (cst instanceof Handle) {
        Handle h = (Handle) cst;
        return newHandle(h.getTag(), h.getOwner(), h.getName(), h.getDesc(), h.isInterface(), isExtend);
    } else {
        throw new IllegalArgumentException("value " + cst);
    }
}

From source file:com.geeksaga.light.profiler.util.ConstantPoolWrapper.java

License:Apache License

public Constant newInvokeDynamic(String name, String desc, Handle bsm, boolean isExtend, Object... bsmArgs) {
    if (isExtend) {
        super.newInvokeDynamic(name, desc, bsm, bsmArgs);
    }/*from  w  ww.j a v a 2 s  .c  o m*/

    key5.set(name, desc, bsm, bsmArgs);

    Constant result = getConstant(key5);
    if (result == null) {
        newNameType(name, desc, isExtend);
        newHandle(bsm.getTag(), bsm.getOwner(), bsm.getName(), bsm.getDesc(), isExtend);

        for (Object bsmArg : bsmArgs) {
            newConst(bsmArg, isExtend);
        }

        return putConstant(new Constant(key5));
    }

    return result;
}

From source file:com.github.anba.es6draft.compiler.assembler.SimpleTypeTextifier.java

License:Open Source License

@Override
public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) {
    buf.setLength(0);//from ww  w  . j  ava  2 s .co  m
    buf.append(tab2).append("INVOKEDYNAMIC").append(' ').append(name);
    appendDescriptor(METHOD_DESCRIPTOR, desc);
    if (bsmArgs.length != 0) {
        buf.append(" [");
        for (int i = 0; i < bsmArgs.length; ++i) {
            Object arg = bsmArgs[i];
            if (arg instanceof String) {
                appendString(buf, (String) arg);
            } else if (arg instanceof Type) {
                Type type = (Type) arg;
                if (type.getSort() == Type.METHOD) {
                    appendDescriptor(METHOD_DESCRIPTOR, type.getDescriptor());
                } else {
                    appendDescriptor(INTERNAL_NAME, type.getDescriptor());
                }
            } else if (arg instanceof Handle) {
                Handle handle = (Handle) arg;
                appendDescriptor(HANDLE_DESCRIPTOR, getMethodDescriptor(handle.getDesc()));
            } else {
                buf.append(arg);
            }
            if (i + 1 < bsmArgs.length) {
                buf.append(", ");
            }
        }
        buf.append("]");
    }
    buf.append("\n");

    text.add(buf.toString());
}

From source file:com.github.anba.es6draft.compiler.assembler.SimpleTypeTextifier.java

License:Open Source License

@Override
public void visitLdcInsn(Object cst) {
    if (cst instanceof Handle) {
        Handle handle = (Handle) cst;
        handle = new Handle(handle.getTag(), handle.getOwner(), handle.getName(),
                getMethodDescriptor(handle.getDesc()));
        buf.setLength(0);//from  w w  w .j a v  a2s.co  m
        buf.append(tab2).append("LDC ");
        buf.append(handle.getOwner()).append('.').append(handle.getName()).append(handle.getDesc());
        buf.append('\n');
        text.add(buf.toString());
        return;
    }
    super.visitLdcInsn(cst);
}

From source file:com.github.cojac.FloatReplacerMethodVisitor.java

License:Apache License

@Override
public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) {
    if (!bsm.getOwner().equals("java/lang/invoke/LambdaMetafactory")) {
        mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs);
        return; // TODO: handle any bootstrap method in invokedynamic
    }//from   w  ww  . j  ava2s  .c  o  m
    if (!(bsmArgs[0] instanceof Type) || !(bsmArgs[1] instanceof Handle) || !(bsmArgs[2] instanceof Type)) {
        mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs);
        return;
    }
    Type a0 = (Type) (bsmArgs[0]);
    Type a2 = (Type) (bsmArgs[2]);
    Handle target = (Handle) (bsmArgs[1]);
    String handleOwner = target.getOwner();
    if (!references.hasToBeInstrumented(handleOwner)) {
        mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs);
        return;
    }
    Object[] bsmArgsAfter = new Object[bsmArgs.length];
    for (int i = 0; i < bsmArgs.length; i++) {
        bsmArgsAfter[i] = bsmArgs[i];
    }
    String a0Before = a0.getInternalName(), a2Before = a2.getInternalName();
    String a0After = replaceFloatMethodDescription(a0Before), a2After = replaceFloatMethodDescription(a2Before);
    bsmArgsAfter[0] = Type.getType(a0After);
    bsmArgsAfter[2] = Type.getType(a2After);
    bsmArgsAfter[1] = new Handle(target.getTag(), target.getOwner(), target.getName(),
            replaceFloatMethodDescription(target.getDesc()));
    desc = replaceFloatMethodDescription(desc);
    mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgsAfter);
}

From source file:com.github.wolf480pl.mias4j.java8.rewrite.AbstractDynamicRewritePolicy.java

License:Open Source License

@Override
public Handle interceptDynamic(Type caller, String name, Type desc, Handle bootstrapMethod,
        Object[] bootstrapArgs, List<Object> newBootstrapArgs) throws RewriteAbortException {
    InvocationType invType = InvocationType.fromHandleOpcode(bootstrapMethod.getTag());
    Type bsmOwner = Type.getObjectType(bootstrapMethod.getOwner());
    Type bsmType = Type.getMethodType(bootstrapMethod.getDesc());

    boolean should = shouldIntercept(caller, invType, bsmOwner, bootstrapMethod.getName(), bsmType);

    if (!should) {
        return null;
    }/*from  ww w.  j  av a 2  s .c o m*/

    newBootstrapArgs.add(invType.id());
    newBootstrapArgs.add(bsmOwner.getClassName());
    newBootstrapArgs.add(bootstrapMethod.getName());
    newBootstrapArgs.add(bsmType);
    // NOTE: Varags collection for bootstrap methods works only since Java 8
    newBootstrapArgs.addAll(Arrays.asList(bootstrapArgs));

    return new Handle(Opcodes.H_INVOKESTATIC, Type.getInternalName(Bootstraps.class), WRAPDYNAMIC_NAME,
            WRAPDYNAMIC_DESC);
}

From source file:com.google.devtools.build.android.desugar.LambdaDesugaring.java

License:Open Source License

@Override
public void visitEnd() {
    for (Map.Entry<Handle, MethodReferenceBridgeInfo> bridge : bridgeMethods.entrySet()) {
        Handle original = bridge.getKey();
        Handle neededMethod = bridge.getValue().bridgeMethod();
        checkState(/*from w ww  .jav a  2  s. c o m*/
                neededMethod.getTag() == Opcodes.H_INVOKESTATIC
                        || neededMethod.getTag() == Opcodes.H_INVOKEVIRTUAL,
                "Cannot generate bridge method %s to reach %s", neededMethod, original);
        checkState(bridge.getValue().referenced() != null, "Need referenced method %s to generate bridge %s",
                original, neededMethod);

        int access = Opcodes.ACC_BRIDGE | Opcodes.ACC_SYNTHETIC | Opcodes.ACC_FINAL;
        if (neededMethod.getTag() == Opcodes.H_INVOKESTATIC) {
            access |= Opcodes.ACC_STATIC;
        }
        MethodVisitor bridgeMethod = super.visitMethod(access, neededMethod.getName(), neededMethod.getDesc(),
                (String) null, toInternalNames(bridge.getValue().referenced().getExceptionTypes()));

        // Bridge is a factory method calling a constructor
        if (original.getTag() == Opcodes.H_NEWINVOKESPECIAL) {
            bridgeMethod.visitTypeInsn(Opcodes.NEW, original.getOwner());
            bridgeMethod.visitInsn(Opcodes.DUP);
        }

        int slot = 0;
        if (neededMethod.getTag() != Opcodes.H_INVOKESTATIC) {
            bridgeMethod.visitVarInsn(Opcodes.ALOAD, slot++);
        }
        Type neededType = Type.getMethodType(neededMethod.getDesc());
        for (Type arg : neededType.getArgumentTypes()) {
            bridgeMethod.visitVarInsn(arg.getOpcode(Opcodes.ILOAD), slot);
            slot += arg.getSize();
        }
        bridgeMethod.visitMethodInsn(invokeOpcode(original), original.getOwner(), original.getName(),
                original.getDesc(), original.isInterface());
        bridgeMethod.visitInsn(neededType.getReturnType().getOpcode(Opcodes.IRETURN));

        bridgeMethod.visitMaxs(0, 0); // rely on class writer to compute these
        bridgeMethod.visitEnd();
    }
    super.visitEnd();
}

From source file:com.google.devtools.build.android.desugar.LambdaDesugaring.java

License:Open Source License

/**
 * Makes {@link #visitEnd} generate a bridge method for the given method handle if the
 * referenced method will be invisible to the generated lambda class.
 *
 * @return struct containing either {@code invokedMethod} or {@code invokedMethod} and a handle
 *     representing the bridge method that will be generated for {@code invokedMethod}.
 *///from w  w  w.j  a  v a 2  s .co  m
private MethodReferenceBridgeInfo queueUpBridgeMethodIfNeeded(Handle invokedMethod)
        throws ClassNotFoundException {
    if (invokedMethod.getName().startsWith("lambda$")) {
        // We adjust lambda bodies to be visible
        return MethodReferenceBridgeInfo.noBridge(invokedMethod);
    }

    // invokedMethod is a method reference if we get here
    Executable invoked = findTargetMethod(invokedMethod);
    if (isVisibleToLambdaClass(invoked, invokedMethod.getOwner())) {
        // Referenced method is visible to the generated class, so nothing to do
        return MethodReferenceBridgeInfo.noBridge(invokedMethod);
    }

    // We need a bridge method if we get here
    checkState(!isInterface, "%s is an interface and shouldn't need bridge to %s", internalName, invokedMethod);
    checkState(!invokedMethod.isInterface(), "%s's lambda classes can't see interface method: %s", internalName,
            invokedMethod);
    MethodReferenceBridgeInfo result = bridgeMethods.get(invokedMethod);
    if (result != null) {
        return result; // we're already queued up a bridge method for this method reference
    }

    String name = uniqueInPackage(internalName, "bridge$lambda$" + bridgeMethods.size());
    Handle bridgeMethod;
    switch (invokedMethod.getTag()) {
    case Opcodes.H_INVOKESTATIC:
        bridgeMethod = new Handle(invokedMethod.getTag(), internalName, name, invokedMethod.getDesc(),
                /*itf*/ false);
        break;
    case Opcodes.H_INVOKEVIRTUAL:
    case Opcodes.H_INVOKESPECIAL: // we end up calling these using invokevirtual
        bridgeMethod = new Handle(Opcodes.H_INVOKEVIRTUAL, internalName, name, invokedMethod.getDesc(),
                /*itf*/ false);
        break;
    case Opcodes.H_NEWINVOKESPECIAL: {
        // Call invisible constructor through generated bridge "factory" method, so we need to
        // compute the descriptor for the bridge method from the constructor's descriptor
        String desc = Type.getMethodDescriptor(Type.getObjectType(invokedMethod.getOwner()),
                Type.getArgumentTypes(invokedMethod.getDesc()));
        bridgeMethod = new Handle(Opcodes.H_INVOKESTATIC, internalName, name, desc, /*itf*/ false);
        break;
    }
    case Opcodes.H_INVOKEINTERFACE:
        // Shouldn't get here
    default:
        throw new UnsupportedOperationException("Cannot bridge " + invokedMethod);
    }
    result = MethodReferenceBridgeInfo.bridge(invokedMethod, invoked, bridgeMethod);
    MethodReferenceBridgeInfo old = bridgeMethods.put(invokedMethod, result);
    checkState(old == null, "Already had bridge %s so we don't also want %s", old, result);
    return result;
}