Java IntInsnNode.getOpcode方法代码示例

import org.objectweb.asm.tree.IntInsnNode; //导入方法依赖的package包/类
private void updateState(IntInsnNode insn) {
  switch (insn.getOpcode()) {
    case Opcodes.BIPUSH:
    case Opcodes.SIPUSH: {
      state.push(Type.INT_TYPE);
      break;
    }
    case Opcodes.NEWARRAY: {
      String desc = arrayTypeDesc(insn.operand);
      Type type = Type.getType(desc);
      state.pop();
      state.push(type);
      break;
    }
    default:
      throw new Unreachable("Unexpected IntInsn opcode: " + insn.getOpcode());
  }
}
 

import org.objectweb.asm.tree.IntInsnNode; //导入方法依赖的package包/类
private void build(IntInsnNode insn, IRBuilder builder) {
  switch (insn.getOpcode()) {
    case Opcodes.BIPUSH:
    case Opcodes.SIPUSH: {
      int dest = state.push(Type.INT_TYPE);
      builder.addIntConst(dest, insn.operand);
      break;
    }
    case Opcodes.NEWARRAY: {
      String desc = arrayTypeDesc(insn.operand);
      Type type = Type.getType(desc);
      DexType dexType = application.getTypeFromDescriptor(desc);
      int count = state.pop(Type.INT_TYPE).register;
      int array = state.push(type);
      builder.addNewArrayEmpty(array, count, dexType);
      break;
    }
    default:
      throw new Unreachable("Unexpected IntInsn opcode: " + insn.getOpcode());
  }
}
 

import org.objectweb.asm.tree.IntInsnNode; //导入方法依赖的package包/类
/**
 * Reads the given {@link IntInsnNode} instruction and adds the associated {@link Expression} to
 * the given {@link Stack}.
 * 
 * @param intInsnNode the instruction to read
 * @param expressionStack the expression stack to put on or pop from.
 * @param localVariables the local variables
 */
private static void readIntInstruction(final IntInsnNode intInsnNode,
    final Stack<Expression> expressionStack, final LocalVariables localVariables) {
  switch (intInsnNode.getOpcode()) {
    case Opcodes.BIPUSH:
      // expressionStack.add(LiteralFactory.getLiteral(intInsnNode.operand,
      // expressionStack.peek()));
      final Expression literal = new NumberLiteral(intInsnNode.operand);
      LOGGER.trace("Stacking literal {}", literal);
      expressionStack.add(literal);
      break;
    default:
      LOGGER.warn("IntInsnNode with OpCode {} was ignored.", intInsnNode.getOpcode());
  }
}
 

import org.objectweb.asm.tree.IntInsnNode; //导入方法依赖的package包/类
private void convertIntInsn(IntInsnNode insn) {
	int op = insn.getOpcode();
	StackFrame frame = getFrame(insn);
	Operand[] out = frame.out();
	Operand opr;
	if (out == null) {
		Value v;
		if (op == BIPUSH || op == SIPUSH) {
			v = IntConstant.v(insn.operand);
		} else {
			Type type;
			switch (insn.operand) {
			case T_BOOLEAN:
				type = BooleanType.v();
				break;
			case T_CHAR:
				type = CharType.v();
				break;
			case T_FLOAT:
				type = FloatType.v();
				break;
			case T_DOUBLE:
				type = DoubleType.v();
				break;
			case T_BYTE:
				type = ByteType.v();
				break;
			case T_SHORT:
				type = ShortType.v();
				break;
			case T_INT:
				type = IntType.v();
				break;
			case T_LONG:
				type = LongType.v();
				break;
			default:
				throw new AssertionError("Unknown NEWARRAY type!");
			}
			Operand size = popImmediate();
			NewArrayExpr anew = Jimple.v().newNewArrayExpr(type, size.stackOrValue());
			size.addBox(anew.getSizeBox());
			frame.in(size);
			frame.boxes(anew.getSizeBox());
			v = anew;
		}
		opr = new Operand(insn, v);
		frame.out(opr);
	} else {
		opr = out[0];
		if (op == NEWARRAY)
			frame.mergeIn(pop());
	}
	push(opr);
}
 

import org.objectweb.asm.tree.IntInsnNode; //导入方法依赖的package包/类
private void interpret(IntInsnNode insn, FrameState frame, BBInfo block) {
	int operand = insn.operand;
	switch (insn.getOpcode()) {
		case Opcodes.BIPUSH:
		case Opcodes.SIPUSH:
			frame.stack.push(module.constants().getSmallestIntConstant(insn.operand));
			break;
		case Opcodes.NEWARRAY:
			ArrayType t;
			switch (operand) {
				case Opcodes.T_BOOLEAN:
					t = module.types().getArrayType(boolean[].class);
					break;
				case Opcodes.T_BYTE:
					t = module.types().getArrayType(byte[].class);
					break;
				case Opcodes.T_CHAR:
					t = module.types().getArrayType(char[].class);
					break;
				case Opcodes.T_SHORT:
					t = module.types().getArrayType(short[].class);
					break;
				case Opcodes.T_INT:
					t = module.types().getArrayType(int[].class);
					break;
				case Opcodes.T_LONG:
					t = module.types().getArrayType(long[].class);
					break;
				case Opcodes.T_FLOAT:
					t = module.types().getArrayType(float[].class);
					break;
				case Opcodes.T_DOUBLE:
					t = module.types().getArrayType(double[].class);
					break;
				default:
					throw new AssertionError(operand);
			}
			NewArrayInst i = new NewArrayInst(t, frame.stack.pop());
			block.block.instructions().add(i);
			frame.stack.push(i);
			break;
		default:
			throw new UnsupportedOperationException(""+insn.getOpcode());
	}
}