Java Opcodes.GETSTATIC属性代码示例

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

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

@Override
public void visitFieldInsn(int opcode, String owner, String name, String desc) {
  DexField field = application.getField(owner, name, desc);
  switch (opcode) {
    case Opcodes.GETFIELD:
      registry.registerInstanceFieldRead(field);
      break;
    case Opcodes.PUTFIELD:
      registry.registerInstanceFieldWrite(field);
      break;
    case Opcodes.GETSTATIC:
      registry.registerStaticFieldRead(field);
      break;
    case Opcodes.PUTSTATIC:
      registry.registerStaticFieldWrite(field);
      break;
    default:
      throw new Unreachable("Unexpected opcode " + opcode);
  }
}
 

private void updateState(FieldInsnNode insn) {
  Type type = Type.getType(insn.desc);
  switch (insn.getOpcode()) {
    case Opcodes.GETSTATIC:
      state.push(type);
      break;
    case Opcodes.PUTSTATIC:
      state.pop();
      break;
    case Opcodes.GETFIELD: {
      state.pop(JarState.OBJECT_TYPE);
      state.push(type);
      break;
    }
    case Opcodes.PUTFIELD: {
      state.pop();
      state.pop(JarState.OBJECT_TYPE);
      break;
    }
    default:
      throw new Unreachable("Unexpected FieldInsn opcode: " + insn.getOpcode());
  }
}
 

public SkillsHook() {
	super(new Regex(
			new Instruction(Opcodes.GETSTATIC, true),
			new Instruction(Opcodes.ALOAD, false),
			new Instruction(Opcodes.ILOAD, false),
			new Instruction(Opcodes.IINC, false),
			new Instruction(Opcodes.IALOAD, false),
			new Instruction(Opcodes.IALOAD, false),
			new Instruction(Opcodes.ISTORE, false),
			new Instruction(Opcodes.ILOAD, false),
			new Or(new Instruction(Opcodes.ICONST_2, false), new Instruction(Opcodes.IF_ICMPNE, false), false),
			new Or(new Instruction(Opcodes.ICONST_2, false), new Instruction(Opcodes.IF_ICMPNE, false), false),
			new Instruction(Opcodes.GETSTATIC, true),
			new Instruction(Opcodes.ALOAD, false),
			new Instruction(Opcodes.ILOAD, false),
			new Instruction(Opcodes.IINC, false),
			new Instruction(Opcodes.IALOAD, false),
			new Instruction(Opcodes.IALOAD, false),
			new Instruction(Opcodes.ISTORE, false),
			new Or(new Instruction(Opcodes.ILOAD, false), new Instruction(Opcodes.ICONST_3, false), false),
			new Or(new Instruction(Opcodes.ILOAD, false), new Instruction(Opcodes.ICONST_3, false), false),
			new Instruction(Opcodes.IF_ICMPNE, false),
			new Instruction(Opcodes.GETSTATIC, true)
		));
}
 

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

@SuppressWarnings("unused")
protected void onMethodEnter() {
	if (done) return;

	overridden = true;
	Label start  = new Label();
	Label normal = new Label();
	super.visitLabel(start);
	super.visitFieldInsn(Opcodes.GETSTATIC, CONFIGURATION, CONFIGURATION_FIELD_NAME, Type.INT_TYPE.getDescriptor());
	super.visitInsn(Opcodes.DUP);
	super.visitJumpInsn(Opcodes.IFEQ, normal);
	super.visitInsn(Opcodes.IRETURN);
	super.visitLabel(normal);
	super.visitInsn(Opcodes.POP);
	Label end = new Label();
	super.visitJumpInsn(Opcodes.GOTO, end);
	super.visitLabel(end);
	super.visitTryCatchBlock(start, normal, end, Type.getType(Throwable.class).getDescriptor());
}
 

@Override
public void visitFieldInsn(int opcode, String originalType, String originalName, String desc)
{
    // This method solves the problem of a static field reference changing type. In all probability it is a
    // compatible change, however we need to fix up the desc to point at the new type
    String type = remapper.mapType(originalType);
    String fieldName = remapper.mapFieldName(originalType, originalName, desc);
    String newDesc = remapper.mapDesc(desc);
    if (opcode == Opcodes.GETSTATIC && type.startsWith("net/minecraft/") && newDesc.startsWith("Lnet/minecraft/"))
    {
        String replDesc = FMLDeobfuscatingRemapper.INSTANCE.getStaticFieldType(originalType, originalName, type, fieldName);
        if (replDesc != null)
        {
            newDesc = remapper.mapDesc(replDesc);
        }
    }
    // super.super
    if (mv != null) {
        mv.visitFieldInsn(opcode, type, fieldName, newDesc);
    }
}
 

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

        @Override
        public void visitFieldInsn(int opcode, String owner, String fieldName,
                                   String fieldDesc) {
            if (opcode != Opcodes.GETSTATIC || owner.startsWith("java/lang/")) {
                // skip!
                this.mv.visitFieldInsn(opcode, owner, fieldName, fieldDesc);
                return;
            }
            String typeName = owner.substring(owner.lastIndexOf('/') + 1);
            String key = typeName + '.' + fieldName;
            if (rSymbols.containsKey(key)) {
                Integer value = rSymbols.get(key);
                if (value == null)
                    throw new UnsupportedOperationException("value of " + key + " is null!");
                if (logger.isEnabled(LogLevel.DEBUG)) {
                    logger.debug("replace {}.{} to 0x{}", owner, fieldName, Integer.toHexString(value));
                }
                pushInt(this.mv, value);
            } else if (owner.endsWith("/R$styleable")) { // replace all */R$styleable ref!
                this.mv.visitFieldInsn(opcode, RSymbols.R_STYLEABLES_CLASS_NAME, fieldName, fieldDesc);
            } else {
                this.mv.visitFieldInsn(opcode, owner, fieldName, fieldDesc);
            }
        }
    };
}
 

public CanvasHook() {
	super(new Regex(
			new Instruction(Opcodes.GOTO, false),
			new Instruction(Opcodes.GETSTATIC, true),
			new Instruction(Opcodes.CHECKCAST, false),
			new Instruction(Opcodes.ALOAD, false),
			new Instruction(Opcodes.GETFIELD, false),
			new Instruction(Opcodes.LDC, false),
			new Instruction(Opcodes.INVOKEVIRTUAL, true),
			new Instruction(Opcodes.GOTO, false)
		));
}
 

public void visitFieldInsn(int opcode, String owner, String fieldName,
		String desc) {
	if (firstInstruction)
		addInc();
	if (logPointerChange && opcode == Opcodes.PUTFIELD
			&& desc.charAt(0) == 'L') {
		if (constructor && !doneSuperConstructor && name.equals(owner)
				&& finalFields.contains(fieldName))
			delayedFieldPointer.put(fieldName, desc);
		else {
			// instrument reference changes from
			// putfield ...,obj,v' => ...
			// to
			// dup2 ...,obj,v' => ...,obj,v',obj,v'
			// swap ...,obj,v',obj,v' => ...,obj,v',v',obj
			// dup ...,obj,v',v',obj => ...,obj,v',v',obj,obj
			// getfield ...,obj,v',v',obj,obj => ...,obj,v',v',obj,v
			// invokespecial
			// pointerchangelog(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V
			// ...,obj,v',v',obj,v => ...,obj,v'
			// putfield ...,obj,v' =>
			super.visitInsn(Opcodes.DUP2);
			super.visitInsn(Opcodes.SWAP);
			super.visitInsn(Opcodes.DUP);
			super.visitFieldInsn(Opcodes.GETFIELD, owner, fieldName,
					desc);
			super.visitMethodInsn(Opcodes.INVOKESTATIC, name,
					LOG_INTERNAL_POINTER_CHANGE,
					POINTER_CHANGE_SIGNATURE);
		}
	} else if (logPointerChange && opcode == Opcodes.PUTSTATIC
			&& desc.charAt(0) == 'L') {
		// if (finalFields.contains(fieldName)) {
		// // assume field is initially null
		// super.visitInsn(Opcodes.DUP);
		// } else {
		// instrument reference changes from
		// putstatic ...,v' => ...
		// to
		// dup ...,v' => ...,v',v'
		// ldc owner.class ...,v',v' => ...,v',v',k
		// getstatic ...,v',v',k => ...,v',v',k,v
		// invokespecial
		// staticpointerchangelog(Ljava/lang/Object;Ljava/lang/Class;Ljava/lang/Object;)V
		// ...,v',v',k,v => ...,v'
		super.visitInsn(Opcodes.DUP);
		super.visitLdcInsn(Type.getObjectType(owner));
		super.visitFieldInsn(Opcodes.GETSTATIC, owner, fieldName, desc);
		super.visitMethodInsn(Opcodes.INVOKESTATIC, name,
				LOG_INTERNAL_STATIC_POINTER_CHANGE,
				STATIC_POINTER_CHANGE_SIGNATURE);
		// }
	}
	super.visitFieldInsn(opcode, owner, fieldName, desc);
}
 

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

private boolean isFieldRead(int opcode) {
	return opcode == Opcodes.GETFIELD || opcode == Opcodes.GETSTATIC;
}
 

private static void overclockServer(ClassNode node, boolean isObfuscated)
{
    // We're attempting to replace this code (from the heart of MinecraftServer.run):
    /*       
        {
            while (i > 50L)
            {
                i -= 50L;
                this.tick();
            }
        }

        Thread.sleep(Math.max(1L, 50L - i));
    */

    // With this:
    /*       
    {
        while (i > TimeHelper.serverTickLength)
        {
            i -= TimeHelper.serverTickLength;
            this.tick();
        }
    }

    Thread.sleep(Math.max(1L, TimeHelper.serverTickLength - i));
*/
    // This allows us to alter the tick length via TimeHelper.
    
    final String methodName = "run";
    final String methodDescriptor = "()V"; // No params, returns void.

    System.out.println("MALMO: Found MinecraftServer, attempting to transform it");

    for (MethodNode method : node.methods)
    {
        if (method.name.equals(methodName) && method.desc.equals(methodDescriptor))
        {
            System.out.println("MALMO: Found MinecraftServer.run() method, attempting to transform it");
            for (AbstractInsnNode instruction : method.instructions.toArray())
            {
                if (instruction.getOpcode() == Opcodes.LDC)
                {
                    Object cst = ((LdcInsnNode)instruction).cst;
                    if ((cst instanceof Long) && (Long)cst == 50)
                    {
                        System.out.println("MALMO: Transforming LDC");
                        AbstractInsnNode replacement = new FieldInsnNode(Opcodes.GETSTATIC, "com/microsoft/Malmo/Utils/TimeHelper", "serverTickLength", "J");
                        method.instructions.set(instruction, replacement);
                    }
                }
            }
        }
    }
}