Java 类org.objectweb.asm.Opcodes 实例源码

@Override
public void visitVarInsn(final int opcode, final int var) {
  ReplacingBasicValue v;
  if (opcode == Opcodes.ASTORE && (v = peekFromTop(0)) != null) {
    final ValueHolderSub from = oldToNew.get(v.getIndex());

    final ReplacingBasicValue current = getLocal(var);
    // if local var is set, then transfer to it to the existing holders in the local position.
    if (current != null) {
      final ValueHolderSub newSub = oldToNew.get(current.getIndex());
      if (newSub.iden() == from.iden()) {
        final int targetFirst = newSub.first();
        from.transfer(this, targetFirst);
        return;
      }
    }

    // if local var is not set, then check map to see if existing holders are mapped to local var.
    if (oldLocalToFirst.containsKey(var)) {
      final ValueHolderSub sub = oldToNew.get(oldLocalToFirst.lget());
      if (sub.iden() == from.iden()) {
        // if they are, then transfer to that.
        from.transfer(this, sub.first());
        return;
      }
    }

    // map from variables to global space for future use.
    oldLocalToFirst.put(var, v.getIndex());
    return;
  } else if (opcode == Opcodes.ALOAD && (v = getLocal(var)) != null) {
    /*
     * Not forwarding this removes a now unnecessary ALOAD for a holder. The required LOAD/STORE
     * sequences will be generated by the ASTORE code above.
     */
    return;
  }

  super.visitVarInsn(opcode, var);
}

@Override
public void visitFieldInsn(final int opcode, final String owner,
        final String name, final String desc) {
    switch (opcode) {
    case Opcodes.GETSTATIC:
        getstatic(owner, name, desc);
        break;
    case Opcodes.PUTSTATIC:
        putstatic(owner, name, desc);
        break;
    case Opcodes.GETFIELD:
        getfield(owner, name, desc);
        break;
    case Opcodes.PUTFIELD:
        putfield(owner, name, desc);
        break;
    default:
        throw new IllegalArgumentException();
    }
}

private void throw_compilation(ASTJumpExpr node) throws CompileException {
  TContextFunc func_context = getClosestFunContext();
  MethodVisitor mv = func_context.getMethodVisitor();

  switch (node.jjtGetNumChildren()) {
  case 1:
    Reduction reduce = this.popReduction();
    Debug.assertion(reduce != null, "Invalid Popped Reduction");
    Debug.assertion(reduce.isContainer(), "Invalid Popped Reduction " + reduce);
    Container throw_cont = (Container) reduce;
    Debug.assertion(throw_cont.isTypeInitialized(), "Throw Type is not initialized in the function signature");

    LOG.debug("CONT TYPE:" + throw_cont.getType());
    Debug.assertion(!throw_cont.isForm(Container.FORM_TYPE), "throw_cont should not be type container");

    LOG.debug("ATHROW");
    mv.visitInsn(Opcodes.ATHROW);
    break;

  default:
    throw new CompileException("Invalid Throw Expression child");
  }

  pushReduction(new Control(Control.FORM_THROW));
}

@Override
public Container smaller(Container lval, Container rvalue, OpInfo opinfo) throws CompileException {

  Label greater_equal_label = new Label();
  Label end_label = new Label();

  opinfo.mv.visitJumpInsn(Opcodes.IF_ICMPGE, greater_equal_label);
  opinfo.mv.visitInsn(Opcodes.ICONST_1);
  opinfo.mv.visitJumpInsn(Opcodes.GOTO, end_label);
  opinfo.mv.visitLabel(greater_equal_label);
  opinfo.mv.visitInsn(Opcodes.ICONST_0);
  opinfo.mv.visitLabel(end_label);

  Container anony_bool = new Container("anonymous", Container.FORM_OPSTACK_VAR, true, false);
  anony_bool.initializeType((AbsType) cpLoader.findClassFull(TPrimitiveClass.NAME_BOOL));
  anony_bool.setAssigned(true);

  return anony_bool;
}

@Override
protected void remap() {
    findNode(getObfType().getJvmStandard()).ifPresent((classNode -> classNode.methods.forEach((methodNode -> {
        if (methodNode.name.equals("<init>")) {
            methodNode.instructions.iterator().forEachRemaining((insnNode) -> {
                if (insnNode.getOpcode() == Opcodes.ANEWARRAY) {
                    if (insnNode instanceof TypeInsnNode) {
                        TypeInsnNode typeInsnNode = (TypeInsnNode) insnNode;
                        Type type = Type.getType(typeInsnNode.desc);
                        getMappings().putClass(type.getInternalName(), "net.minecraft.world" +
                                ".IWorldEventListener");
                    }
                }
            });
        }
    }))));
}

/**
 * Imports field instructions (put and get), both for static and instance
 * fields.
 *
 * @param opcode Opcode.
 * @param owner  Class containing the field.
 * @param name   Name of field.
 * @param desc   Type descriptor of field.
 */
@Override
public void visitFieldInsn(final int opcode, final String owner, final String name, final String desc) {
  Field f = ClassNode.getClass(owner).getField(name, desc);

  if(((opcode == Opcodes.GETSTATIC) || (opcode == Opcodes.PUTSTATIC)) !=
          f.getModifiers().contains(Modifier.STATIC)) {
    throw new RuntimeException("Field staticness conflicts with instruction");
  }

  switch(opcode) {
    // Loads
    case Opcodes.GETSTATIC:
    case Opcodes.GETFIELD:  createFieldRead(f);  break;
    // Stores
    case Opcodes.PUTSTATIC:
    case Opcodes.PUTFIELD:  createFieldWrite(f); break;
  }
}

@Override
public MethodVisitor visitMethod(int access, String name, String desc,
                                 String signature, String[] exceptions) {
    if (attemptToVisitR) return null;
    return new MethodVisitor(Opcodes.ASM5, null) {

        @Override
        public void visitFieldInsn(int opcode, String owner, String fieldName,
                                   String fieldDesc) {

            if (attemptToVisitR
                    || opcode != Opcodes.GETSTATIC
                    || owner.startsWith("java/lang/")) {
                return;
            }

            attemptToVisitR = isRClass(owner);
        }
    };
}

/**
 * Makes the given visitor visit this stack map frame.
 * 
 * @param mv
 *            a method visitor.
 */
@Override
public void accept(final MethodVisitor mv) {
    switch (type) {
    case Opcodes.F_NEW:
    case Opcodes.F_FULL:
        mv.visitFrame(type, local.size(), asArray(local), stack.size(),
                asArray(stack));
        break;
    case Opcodes.F_APPEND:
        mv.visitFrame(type, local.size(), asArray(local), 0, null);
        break;
    case Opcodes.F_CHOP:
        mv.visitFrame(type, local.size(), null, 0, null);
        break;
    case Opcodes.F_SAME:
        mv.visitFrame(type, 0, null, 0, null);
        break;
    case Opcodes.F_SAME1:
        mv.visitFrame(type, 0, null, 1, asArray(stack));
        break;
    }
}

@Override
public Container minus_assign(Container lval, Container rvalue, OpInfo opinfo) throws CompileException {
  Container anonyInt = lval.getOpStackClone("anonymous");
  //// Compiled Instruction
  LOG.info("FSUB");
  opinfo.mv.visitInsn(Opcodes.FSUB);

  do_assign_common(lval, anonyInt, opinfo);

  //// End
  return anonyInt;
}

@Override
public void visitMethodInsn(final int opcode, final String owner,
        final String name, final String desc, final boolean itf) {
    if (api < Opcodes.ASM5) {
        super.visitMethodInsn(opcode, owner, name, desc, itf);
        return;
    }
    doVisitMethodInsn(opcode, owner, name, desc, itf);
}

@Override
public void visitMethodInsn(final int opcode, final String owner,
        final String name, final String desc, final boolean itf) {
    if (api < Opcodes.ASM5) {
        super.visitMethodInsn(opcode, owner, name, desc, itf);
        return;
    }
    doVisitMethodInsn(opcode, owner, name, desc, itf);
}

@Override
public void visitMethodInsn(final int opcode, final String owner,
        final String name, final String desc, final boolean itf) {
    if (api < Opcodes.ASM5) {
        super.visitMethodInsn(opcode, owner, name, desc, itf);
        return;
    }
    doVisitMethodInsn(opcode, owner, name, desc, itf);
}

/**
 * Output instructions for allocating arrays, both for primitive and
 * reference types.
 *
 * @param instruction Array allocation instruction.
 * @return            <code>null</code>
 */
@Override
public Void visit(NewArray instruction) {
  if(instruction.getElementType().getSort() == Type.Sort.REF) {
    mv.visitTypeInsn(
      Opcodes.ANEWARRAY,
      instruction.getElementType().getInternalName()
    );
  } else {
    int type;

    switch(instruction.getElementType().getSort()) {
      case BOOL:   type = Opcodes.T_BOOLEAN; break;
      case CHAR:   type = Opcodes.T_CHAR;    break;
      case FLOAT:  type = Opcodes.T_FLOAT;   break;
      case DOUBLE: type = Opcodes.T_DOUBLE;  break;
      case BYTE:   type = Opcodes.T_BYTE;    break;
      case SHORT:  type = Opcodes.T_SHORT;   break;
      case INT:    type = Opcodes.T_INT;     break;
      case LONG:   type = Opcodes.T_LONG;    break;
      default: throw new RuntimeException("Unknown array element type");
    }

    mv.visitIntInsn(Opcodes.NEWARRAY, type);
  }

  return null;
}

@Override
public void transform(ClassNode clazz, MethodNode method, InsnMatcher matcher) {
    method.instructions.clear();
    method.localVariables.clear();
    method.tryCatchBlocks.clear();

    method.instructions.add(new InsnNode(Opcodes.ICONST_0));
    method.instructions.add(new InsnNode(Opcodes.IRETURN));

    // TODO adjust maxLocals and maxStack?
}

@Deprecated
public void invokevirtual(final String owner, final String name,
        final String desc) {
    if (api >= Opcodes.ASM5) {
        invokevirtual(owner, name, desc, false);
        return;
    }
    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc);
}

@Override
protected MethodVisitor hookMethod(int access, String name, String desc, String signature, String[] exceptions, MethodVisitor mv) {
    if ("extractParameters".equals(name) || "extractContentParameters".equals(name)) {
        return new AdviceAdapter(Opcodes.ASM5, mv, access, name, desc) {
            @Override
            protected void onMethodEnter() {
                invokeStatic(Type.getType(HookHandler.class),
                        new Method("onParseParameters", "()V"));
            }

        };
    }
    return mv;
}

@Override
public Container minus(Container lval, Container rvalue, OpInfo opinfo) throws CompileException {

  Container anonyInt = lval.getOpStackClone("anonymous");

  //// Compiled Instruction
  opinfo.mv.visitInsn(Opcodes.ISUB);
  LOG.info("ISUB");
  // subed result will be on the operand stack
  //// End

  return anonyInt;
}

@Override
public void return_dummy_variable(OpInfo opinfo) throws CompileException {

  opinfo.mv.visitInsn(Opcodes.ICONST_1);
  LOG.info("ICONST_1 for boolean");

  opinfo.mv.visitInsn(Opcodes.IRETURN);
  LOG.info("IRETURN" + " for Boolean");
}

/**
 * Generates the instruction to push the given value on the stack.
 * 
 * @param value
 *            the value to be pushed on the stack.
 */
public void push(final double value) {
    long bits = Double.doubleToLongBits(value);
    if (bits == 0L || bits == 0x3ff0000000000000L) { // +0.0d and 1.0d
        mv.visitInsn(Opcodes.DCONST_0 + (int) value);
    } else {
        mv.visitLdcInsn(value);
    }
}

@Override
public BasicValue ternaryOperation(AbstractInsnNode insnNode, BasicValue value1, BasicValue value2, BasicValue value3)
    throws AnalyzerException {
    if (insnNode.getOpcode() == Opcodes.AASTORE && value1 instanceof ArraySizeBasicValue) {
        return value1;
    }
    return super.ternaryOperation(insnNode, value1, value2, value3);
}

@Override
void write(MethodWriter writer, Globals globals) {
    writer.writeStatementOffset(location);

    expression.write(writer, globals);
    writer.visitVarInsn(array.type.type.getOpcode(Opcodes.ISTORE), array.getSlot());
    writer.push(-1);
    writer.visitVarInsn(index.type.type.getOpcode(Opcodes.ISTORE), index.getSlot());

    Label begin = new Label();
    Label end = new Label();

    writer.mark(begin);

    writer.visitIincInsn(index.getSlot(), 1);
    writer.visitVarInsn(index.type.type.getOpcode(Opcodes.ILOAD), index.getSlot());
    writer.visitVarInsn(array.type.type.getOpcode(Opcodes.ILOAD), array.getSlot());
    writer.arrayLength();
    writer.ifICmp(MethodWriter.GE, end);

    writer.visitVarInsn(array.type.type.getOpcode(Opcodes.ILOAD), array.getSlot());
    writer.visitVarInsn(index.type.type.getOpcode(Opcodes.ILOAD), index.getSlot());
    writer.arrayLoad(indexed.type);
    writer.writeCast(cast);
    writer.visitVarInsn(variable.type.type.getOpcode(Opcodes.ISTORE), variable.getSlot());

    if (loopCounter != null) {
        writer.writeLoopCounter(loopCounter.getSlot(), statementCount, location);
    }

    block.continu = begin;
    block.brake = end;
    block.write(writer, globals);

    writer.goTo(begin);
    writer.mark(end);
}

private void addGetter(String methodName, String methodDescriptor, MethodCodeBody body) throws Exception {
    MethodVisitor methodVisitor = visitor.visitMethod(Opcodes.ACC_PUBLIC, methodName, methodDescriptor, null, EMPTY_STRINGS);
    methodVisitor.visitCode();
    body.add(methodVisitor);
    methodVisitor.visitInsn(Opcodes.ARETURN);
    methodVisitor.visitMaxs(0, 0);
    methodVisitor.visitEnd();
}

@Override
public void visitMethodInsn(final int opcode, final String owner,
        final String name, final String desc, final boolean itf) {
    if (api < Opcodes.ASM5) {
        super.visitMethodInsn(opcode, owner, name, desc, itf);
        return;
    }
    doVisitMethodInsn(opcode, owner, name, desc, itf);
}

@Override
public Container shfit_right(Container lval, Container rvalue, OpInfo opinfo) throws CompileException {
  Container anonyInt = lval.getOpStackClone("anonymous");
  //// Compiled Instruction
  LOG.info("ISHR");
  opinfo.mv.visitInsn(Opcodes.ISHR);
  // subed result will be on the operand stack
  //// End
  return anonyInt;
}

@Override
public void visitFrame(final int type, final int nLocal,
        final Object[] local, final int nStack, final Object[] stack) {
    AttributesImpl attrs = new AttributesImpl();
    switch (type) {
    case Opcodes.F_NEW:
    case Opcodes.F_FULL:
        if (type == Opcodes.F_NEW) {
            attrs.addAttribute("", "type", "type", "", "NEW");
        } else {
            attrs.addAttribute("", "type", "type", "", "FULL");
        }
        sa.addStart("frame", attrs);
        appendFrameTypes(true, nLocal, local);
        appendFrameTypes(false, nStack, stack);
        break;
    case Opcodes.F_APPEND:
        attrs.addAttribute("", "type", "type", "", "APPEND");
        sa.addStart("frame", attrs);
        appendFrameTypes(true, nLocal, local);
        break;
    case Opcodes.F_CHOP:
        attrs.addAttribute("", "type", "type", "", "CHOP");
        attrs.addAttribute("", "count", "count", "",
                Integer.toString(nLocal));
        sa.addStart("frame", attrs);
        break;
    case Opcodes.F_SAME:
        attrs.addAttribute("", "type", "type", "", "SAME");
        sa.addStart("frame", attrs);
        break;
    case Opcodes.F_SAME1:
        attrs.addAttribute("", "type", "type", "", "SAME1");
        sa.addStart("frame", attrs);
        appendFrameTypes(false, 1, stack);
        break;
    }
    sa.addEnd("frame");
}

@Override
public Container multiply_assign(Container lval, Container rvalue, OpInfo opinfo) throws CompileException {
  Container anonyInt = lval.getOpStackClone("anonymous");
  //// Compiled Instruction
  LOG.info("IMUL");
  opinfo.mv.visitInsn(Opcodes.IMUL);

  do_assign_common(lval, anonyInt, opinfo);

  //// End
  return anonyInt;
}

void writeMissingMessageWithHash(GeneratorAdapter mv, String visitedClassName) {
    mv.newInstance(INSTANT_RELOAD_EXCEPTION_TYPE);
    mv.dup();
    mv.push("int switch could not find %d in %s");
    mv.push(3);
    mv.newArray(OBJECT_TYPE);
    mv.dup();
    mv.push(0);
    visitInt();
    mv.visitMethodInsn(
            Opcodes.INVOKESTATIC,
            "java/lang/Integer",
            "valueOf",
            "(I)Ljava/lang/Integer;", false);
    mv.arrayStore(OBJECT_TYPE);
    mv.dup();
    mv.push(2);
    mv.push(visitedClassName);
    mv.arrayStore(OBJECT_TYPE);
    mv.visitMethodInsn(
            Opcodes.INVOKESTATIC,
            "java/lang/String",
            "format",
            "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;", false);
    mv.invokeConstructor(INSTANT_RELOAD_EXCEPTION_TYPE,
            Method.getMethod("void <init> (String)"));
    mv.throwException();
}

@Test
public void test_IFLE(){
    //val <= 0  implies !(-val < 0)

    int[] values = new int[]{-2345, -6, 0, 2, 7888};
    for(int val: values){

        Truthness le = getForSingleValueJump(val, Opcodes.IFLE);
        Truthness x = getForSingleValueJump(-val, Opcodes.IFLT).invert();

        //their values should be the same, as equivalent
        assertEquals(le.getOfTrue(), x.getOfTrue(), 0.001);
        assertEquals(le.getOfFalse(), x.getOfFalse(), 0.001);
    }
}

@Override
public Container inclusive_or_assign(Container lval, Container rvalue, OpInfo opinfo) throws CompileException {
  Container anonyInt = lval.getOpStackClone("anonymous");
  //// Compiled Instruction
  LOG.info("IOR");
  opinfo.mv.visitInsn(Opcodes.IOR);

  do_assign_common(lval, anonyInt, opinfo);

  //// End
  return anonyInt;
}

@Override
public void visitMethodInsn(int opcode, String owner, String name,
        String desc, boolean itf) {
    if (api < Opcodes.ASM5) {
        super.visitMethodInsn(opcode, owner, name, desc, itf);
        return;
    }
    instructions.add(new MethodInsnNode(opcode, owner, name, desc, itf));
}

@Override
public void return_dummy_variable(OpInfo opinfo) throws CompileException {

  opinfo.mv.visitInsn(Opcodes.LCONST_1);
  LOG.info("LCONST_1 for Long");

  opinfo.mv.visitInsn(Opcodes.LRETURN);
  LOG.info("LRETURN" + " for Long");
}

/**
 * Writes the opcodes to flip a negative array index (meaning slots from the end of the array) into a 0-based one (meaning slots from
 * the start of the array).
 */
static void writeIndexFlip(MethodWriter writer, Consumer<MethodWriter> writeGetLength) {
    Label noFlip = new Label();
    // Everywhere when it says 'array' below that could also be a list
    // The stack after each instruction:       array, unnormalized_index
    writer.dup();                           // array, unnormalized_index, unnormalized_index
    writer.ifZCmp(Opcodes.IFGE, noFlip);    // array, unnormalized_index
    writer.swap();                          // negative_index, array
    writer.dupX1();                         // array, negative_index, array
    writeGetLength.accept(writer);          // array, negative_index, length
    writer.visitInsn(Opcodes.IADD);         // array, noralized_index
    writer.mark(noFlip);                    // array, noralized_index
}

/**
 * Generates the instruction to push the given value on the stack.
 * 
 * @param value
 *            the value to be pushed on the stack.
 */
public void push(final double value) {
    long bits = Double.doubleToLongBits(value);
    if (bits == 0L || bits == 0x3ff0000000000000L) { // +0.0d and 1.0d
        mv.visitInsn(Opcodes.DCONST_0 + (int) value);
    } else {
        mv.visitLdcInsn(value);
    }
}

public static int transformAccessForInstantRun(int access) {
    IncrementalVisitor.AccessRight accessRight = IncrementalVisitor.AccessRight.fromNodeAccess(access);
    if (accessRight != IncrementalVisitor.AccessRight.PRIVATE) {
        access &= ~Opcodes.ACC_PROTECTED;
        access &= ~Opcodes.ACC_PRIVATE;
        return access | Opcodes.ACC_PUBLIC;
    }
    return access;
}

@Override
public void visitInsn(final int opcode) {
    if (mv != null) {
        mv.visitInsn(opcode);
    }
    execute(opcode, 0, null);
    if ((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN)
            || opcode == Opcodes.ATHROW) {
        this.locals = null;
        this.stack = null;
    }
}

/**
 * Generates the instruction to push the given value on the stack.
 * 
 * @param value
 *            the value to be pushed on the stack.
 */
public void push(final long value) {
    if (value == 0L || value == 1L) {
        mv.visitInsn(Opcodes.LCONST_0 + (int) value);
    } else {
        mv.visitLdcInsn(value);
    }
}

@Test
public void test_IF_ICMPLT_pos_false(){
    // x < y
    int code = Opcodes.IF_ICMPLT;

    Truthness a = getForValueComparison(10, 6, code);
    assertFalse(a.isTrue());

    Truthness b = getForValueComparison(222, 5, code);
    assertFalse(b.isTrue());

    assertTrue(a.getOfTrue() > b.getOfTrue());
}

/**
 * Generates the instruction to create a new array.
 * 
 * @param type
 *            the type of the array elements.
 */
public void newArray(final Type type) {
    int typ;
    switch (type.getSort()) {
    case Type.BOOLEAN:
        typ = Opcodes.T_BOOLEAN;
        break;
    case Type.CHAR:
        typ = Opcodes.T_CHAR;
        break;
    case Type.BYTE:
        typ = Opcodes.T_BYTE;
        break;
    case Type.SHORT:
        typ = Opcodes.T_SHORT;
        break;
    case Type.INT:
        typ = Opcodes.T_INT;
        break;
    case Type.FLOAT:
        typ = Opcodes.T_FLOAT;
        break;
    case Type.LONG:
        typ = Opcodes.T_LONG;
        break;
    case Type.DOUBLE:
        typ = Opcodes.T_DOUBLE;
        break;
    default:
        typeInsn(Opcodes.ANEWARRAY, type);
        return;
    }
    mv.visitIntInsn(Opcodes.NEWARRAY, typ);
}

@Test
public void test_IF_ICMPEQ_pos(){
    // x == y
    int code = Opcodes.IF_ICMPEQ;

    Truthness t = getForValueComparison(5, 5, code);
    assertTrue(t.isTrue());
    assertFalse(t.isFalse());
}

public void lconst(final long cst) {
    if (cst == 0L || cst == 1L) {
        mv.visitInsn(Opcodes.LCONST_0 + (int) cst);
    } else {
        mv.visitLdcInsn(cst);
    }
}