Java Opcodes.NEW屬性代碼示例

@Override
public void visitTypeInsn(final int opcode, final String type) {
    if (opcode == Opcodes.NEW) {
        if (labels == null) {
            Label l = new Label();
            labels = new ArrayList<Label>(3);
            labels.add(l);
            if (mv != null) {
                mv.visitLabel(l);
            }
        }
        for (int i = 0; i < labels.size(); ++i) {
            uninitializedTypes.put(labels.get(i), type);
        }
    }
    if (mv != null) {
        mv.visitTypeInsn(opcode, type);
    }
    execute(opcode, 0, type);
}
 

@Override
public void visitTypeInsn(final int opcode, final String type) {
    Type t = Type.getObjectType(type);
    switch (opcode) {
    case Opcodes.NEW:
        anew(t);
        break;
    case Opcodes.ANEWARRAY:
        newarray(t);
        break;
    case Opcodes.CHECKCAST:
        checkcast(t);
        break;
    case Opcodes.INSTANCEOF:
        instanceOf(t);
        break;
    default:
        throw new IllegalArgumentException();
    }
}
 

public void visitTypeInsn(int opcode, String type) {
	if (firstInstruction)
		addInc();
	super.visitTypeInsn(opcode, type);
	// we deal with Opcodes.NEW through the constructors
	if (opcode == Opcodes.ANEWARRAY) {
		int   siteId = getNextSiteId();
		addLog(true, siteId);
	} else if (DO_NEW_INVOKESPECIAL_SEQUENCE && opcode == Opcodes.NEW) {
		super.visitInsn(Opcodes.DUP);
		Triplet p = new Triplet();
		p.type = type;
		p.var = this.localsBase + 1 + newTypeStack.size();
		p.siteId = getNextSiteId();
		if (this.maxLocals < p.var) {
			this.maxLocals = p.var;
			methodToLargestLocal.put(this.encodedName, new Integer(
					p.var));
		}
		super.setLocalType(p.var, JAVA_LANG_OBJECT_TYPE); // super.newLocal(OBJECT_TYPE);
		newTypeStack.addLast(p);
		super.visitVarInsn(Opcodes.ASTORE, p.var);
	}
}
 

private void addWhereAmI() {
	// 0: new #2; //class java/lang/Exception
	// 3: dup
	// 4: invokespecial #3; //Method java/lang/Exception."<init>":()V
	// 7: invokevirtual #4; //Method
	// java/lang/Exception.printStackTrace:()V
	// 10: return
	// super.visitTypeInsn(Opcodes.NEW, type);
	String exClass = Type.getInternalName(Exception.class);
	super.visitTypeInsn(Opcodes.NEW, exClass);
	super.visitInsn(Opcodes.DUP);
	super.visitMethodInsn(Opcodes.INVOKESPECIAL, exClass, "<init>",
			"()V");
	super.visitMethodInsn(Opcodes.INVOKEVIRTUAL, exClass,
			"printStackTrace", "()V");
}
 

@Override
public void visitTypeInsn(final int opcode, final String type) {
    checkStartCode();
    checkEndCode();
    checkOpcode(opcode, 3);
    checkInternalName(type, "type");
    if (opcode == Opcodes.NEW && type.charAt(0) == '[') {
        throw new IllegalArgumentException(
                "NEW cannot be used to create arrays: " + type);
    }
    super.visitTypeInsn(opcode, type);
    ++insnCount;
}
 

private void updateState(TypeInsnNode insn) {
  Type type = Type.getObjectType(insn.desc);
  switch (insn.getOpcode()) {
    case Opcodes.NEW: {
      state.push(type);
      break;
    }
    case Opcodes.ANEWARRAY: {
      Type arrayType = makeArrayType(type);
      state.pop();
      state.push(arrayType);
      break;
    }
    case Opcodes.CHECKCAST: {
      // Pop the top value and push it back on with the checked type.
      state.pop(type);
      state.push(type);
      break;
    }
    case Opcodes.INSTANCEOF: {
      state.pop(JarState.REFERENCE_TYPE);
      state.push(Type.INT_TYPE);
      break;
    }
    default:
      throw new Unreachable("Unexpected TypeInsn opcode: " + insn.getOpcode());
  }

}
 

/**
 * Imports instructions with a single type operand (allocation of reference
 * arrays, allocation of objects, casting and type checks).
 *
 * @param opcode     Opcode.
 * @param descriptor String descriptor of the type operand.
 */
@Override
public void visitTypeInsn(final int opcode, final String descriptor) {
  Type type = Type.getObjectType(descriptor);

  switch(opcode) {
    // News
    case Opcodes.ANEWARRAY: ordered.add(stack.push(new NewArray(type, stack.pop())));  break;
    case Opcodes.NEW:       ordered.add(stack.push(new NewObject(type)));              break;

    // Type Checks
    case Opcodes.CHECKCAST: ordered.add(stack.push(new CheckCast(stack.pop(), type))); break;
    case Opcodes.INSTANCEOF:ordered.add(stack.push(new InstanceOf(stack.pop(), type)));break;
  }
}
 

@Override
public BasicValue newOperation(final AbstractInsnNode insn) throws AnalyzerException {
  if (insn.getOpcode() == Opcodes.NEW) {
    final TypeInsnNode t = (TypeInsnNode) insn;

    // if this is for a holder class, we'll replace it
    final ValueHolderIden iden = HOLDERS.get(t.desc);
    if (iden != null) {
      return ReplacingBasicValue.create(Type.getObjectType(t.desc), iden, index++, valueList);
    }
  }

  return super.newOperation(insn);
}
 

private boolean canThrow(AbstractInsnNode insn) {
  switch (insn.getOpcode()) {
    case Opcodes.AALOAD:
    case Opcodes.AASTORE:
    case Opcodes.ANEWARRAY:
      // ARETURN does not throw in its dex image.
    case Opcodes.ARRAYLENGTH:
    case Opcodes.ATHROW:
    case Opcodes.BALOAD:
    case Opcodes.BASTORE:
    case Opcodes.CALOAD:
    case Opcodes.CASTORE:
    case Opcodes.CHECKCAST:
    case Opcodes.DALOAD:
    case Opcodes.DASTORE:
      // DRETURN does not throw in its dex image.
    case Opcodes.FALOAD:
    case Opcodes.FASTORE:
      // FRETURN does not throw in its dex image.
    case Opcodes.GETFIELD:
    case Opcodes.GETSTATIC:
    case Opcodes.IALOAD:
    case Opcodes.IASTORE:
    case Opcodes.IDIV:
    case Opcodes.INSTANCEOF:
    case Opcodes.INVOKEDYNAMIC:
    case Opcodes.INVOKEINTERFACE:
    case Opcodes.INVOKESPECIAL:
    case Opcodes.INVOKESTATIC:
    case Opcodes.INVOKEVIRTUAL:
    case Opcodes.IREM:
      // IRETURN does not throw in its dex image.
    case Opcodes.LALOAD:
    case Opcodes.LASTORE:
    case Opcodes.LDIV:
    case Opcodes.LREM:
      // LRETURN does not throw in its dex image.
    case Opcodes.MONITORENTER:
    case Opcodes.MONITOREXIT:
    case Opcodes.MULTIANEWARRAY:
    case Opcodes.NEW:
    case Opcodes.NEWARRAY:
    case Opcodes.PUTFIELD:
    case Opcodes.PUTSTATIC:
      // RETURN does not throw in its dex image.
    case Opcodes.SALOAD:
    case Opcodes.SASTORE:
      return true;
    case Opcodes.LDC: {
      // const-class and const-string* may throw in dex.
      LdcInsnNode ldc = (LdcInsnNode) insn;
      return ldc.cst instanceof String || ldc.cst instanceof Type;
    }
    default:
      return false;
  }
}