Java Opcodes.ANEWARRAY属性代码示例

@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 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());
  }

}
 

@Override
public BasicValue unaryOperation(AbstractInsnNode insnNode, BasicValue value) throws AnalyzerException {
    if (insnNode.getOpcode() == Opcodes.ANEWARRAY && value instanceof IntegerConstantBasicValue) {
        IntegerConstantBasicValue constantBasicValue = (IntegerConstantBasicValue) value;
        String desc = ((TypeInsnNode) insnNode).desc;
        return new ArraySizeBasicValue(Type.getType("[" + Type.getObjectType(desc)), constantBasicValue.minValue,
            constantBasicValue.maxValue);
    }
    return super.unaryOperation(insnNode, value);
}
 

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

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