Java Code Examples for org.objectweb.asm.Opcodes#PUTFIELD

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

@Redirect(
    method = "tickNetherPortalCooldown",
    at = @At(
        value = "FIELD",
        target = "Lnet/minecraft/server/network/ServerPlayerEntity;netherPortalCooldown:I",
        opcode = Opcodes.PUTFIELD
    )
)
private void realTimeImpl$adjustForRealTimePortalCooldown(final ServerPlayerEntity self, final int modifier) {
    final int ticks = (int) ((RealTimeTrackingBridge) this.world).realTimeBridge$getRealTimeTicks();
    // The initially apparent function of timeUntilPortal is a cooldown for
    // nether portals. However, there is a much more important use:
    // preventing players from being immediately sent back to the other end
    // of the portal. Since it only checks timeUntilPortal to determine
    // whether the player was just in a portal, if timeUntilPortal gets set
    // to 0, it assumes the player left and reentered the portal (see
    // Entity.setPortal()). To prevent this, "snag" the value of
    // timeUntilPortal at 1. If setPortal() does not reset it (the player
    // exits the portal), modifier will become 0, indicating that it is
    // OK to teleport the player.
    this.netherPortalCooldown = Math.max(modifier > 0 ? 1 : 0, this.netherPortalCooldown - ticks);
}
 

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

@Override
public void visitFieldInsn(int opcode, String owner, String name, String desc) {
	super.visitFieldInsn(opcode, owner, name, desc);

	if (!instrumentationActions.trackFieldAssignments) {
		return;
	}

	if (Opcodes.PUTFIELD != opcode && Opcodes.PUTSTATIC != opcode) {
		// Only track field state and name at stores (assignments).
		return;
	}

	for (AccessedField accessedField : accessedFields) {
		if (accessedField.name.equals(name)) {
			instrumentToTrackFieldState(accessedField, lineNumber);
			break;
		}
	}
}
 

@Redirect(method = "tick",
    at = @At(
        value = "FIELD",
        target = "Lnet/minecraft/block/entity/AbstractFurnaceBlockEntity;burnTime:I",
        opcode = Opcodes.PUTFIELD
    ),
    slice = @Slice(
        from = @At(
            value = "INVOKE",
            target = "Lnet/minecraft/block/entity/AbstractFurnaceBlockEntity;isBurning()Z",
            opcode = 1
        ),
        to = @At(
            value = "FIELD",
            target = "Lnet/minecraft/block/entity/AbstractFurnaceBlockEntity;world:Lnet/minecraft/world/World;",
            opcode = Opcodes.GETFIELD,
            ordinal = 0
        )
    )
)
private void realTimeImpl$adjustForRealTimeBurnTime(final AbstractFurnaceBlockEntity self, final int modifier) {
    final int ticks = (int) ((RealTimeTrackingBridge) this.getWorld()).realTimeBridge$getRealTimeTicks();
    this.burnTime = Math.max(0, this.burnTime - Math.max(1, ticks - 1));
}
 

/**
 * @param opcode
 * @param owner
 * @param name
 * @param desc
 * @param s
 */
static void handleFieldInsn ( int opcode, String owner, String name, String desc, JVMStackState s ) {
    switch ( opcode ) {
    case Opcodes.GETFIELD:
        Object tgt = s.pop();
        if ( log.isTraceEnabled() ) {
            log.trace("From " + tgt); //$NON-NLS-1$
        }
    case Opcodes.GETSTATIC:
        // this can be more specific
        if ( log.isTraceEnabled() ) {
            log.trace("Load field " + name + " (" + desc + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
        }
        s.push(new FieldReference(DotName.createSimple(owner.replace('/', '.')), name, Type.getType(desc), true));
        break;
    case Opcodes.PUTFIELD:
        s.pop();
        s.pop();
        break;
    case Opcodes.PUTSTATIC:
        s.pop();
        break;
    default:
        log.warn("Unsupported opcode " + opcode); //$NON-NLS-1$
    }
}
 

@Override
public void visitFieldInsn(int opcode,
        String owner,
        String name,
        String desc) {
    if (opcode == Opcodes.PUTFIELD && parameterLoadState == ParameterLoadState.LOADED_THIS_AND_PARAMETER
            && owner.equals(slashedClassName) && name.startsWith("this$")) {
        // the field that has name starts with "this$" is generated for non-static inner class
        // https://sourceforge.net/p/findbugs/bugs/1015/
        mBuilder.setVariableIsSynthetic(parameterForLoadState);
    }
    fieldInstructionCount++;

    if (isAccessMethod && this.accessOwner == null) {
        this.accessOwner = owner;
        this.accessName = name;
        this.accessDesc = desc;
        this.accessIsStatic = opcode == Opcodes.GETSTATIC || opcode == Opcodes.PUTSTATIC;
        this.accessForField = true;
    }
    visitSomeInsn();
}
 

@Override
public MethodNode generate() {
    if (this.mutable) {
        this.targetField.access &= ~Opcodes.ACC_FINAL;
    }
    
    int stackSpace = this.targetIsStatic ? 0 : 1; // Stack space for "this"
    int maxLocals = stackSpace + this.targetType.getSize();
    int maxStack = stackSpace + this.targetType.getSize();
    MethodNode method = this.createMethod(maxLocals, maxStack);
    if (!this.targetIsStatic) {
        method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
    }
    method.instructions.add(new VarInsnNode(this.targetType.getOpcode(Opcodes.ILOAD), stackSpace));
    int opcode = this.targetIsStatic ? Opcodes.PUTSTATIC : Opcodes.PUTFIELD;
    method.instructions.add(new FieldInsnNode(opcode, this.info.getClassNode().name, this.targetField.name, this.targetField.desc));
    method.instructions.add(new InsnNode(Opcodes.RETURN));
    return method;
}
 

@Redirect(
    method = "update",
    at = @At(
        value = "FIELD",
        target = "Lnet/minecraft/server/network/ServerPlayerInteractionManager;tickCounter:I",
        opcode = Opcodes.PUTFIELD
    )
)
private void realTimeImpl$adjustForRealTimeDiggingTime(final ServerPlayerInteractionManager self, final int modifier) {
    final int ticks = (int) ((RealTimeTrackingBridge) world.getServer()).realTimeBridge$getRealTimeTicks();
    this.tickCounter += ticks;
}
 

@Redirect(
    method = "tick",
    at = @At(
        value = "FIELD",
        target = "Lnet/minecraft/server/network/ServerPlayNetworkHandler;messageCooldown:I",
        opcode = Opcodes.PUTFIELD,
        ordinal = 0
    )
)
private void realTimeImpl$adjustForRealTimeChatSpamCheck(final ServerPlayNetworkHandler self, final int modifier) {
    final int ticks = (int) ((RealTimeTrackingBridge) this.server).realTimeBridge$getRealTimeTicks();
    this.messageCooldown = Math.max(0, this.messageCooldown - ticks);
}
 

@Override
public void visitFieldInsn(int opcode, String owner, String name, String desc) {
    switch (opcode) {
    case Opcodes.GETSTATIC:
    case Opcodes.GETFIELD:
        invokeBeforeSharedVariableRead();
        break;
    case Opcodes.PUTSTATIC:
    case Opcodes.PUTFIELD:
        invokeBeforeSharedVariableWrite();
        break;
    }
    super.visitFieldInsn(opcode, owner, name, desc);
}
 

public void visitFieldInsn(int opcode, String owner, String name,
    String desc) {
  if (opcode == Opcodes.PUTFIELD && LineNumberReader.this.name.equals(owner)
      && !lines.containsKey(name) && line != -1) {
    lines.put(name, line);
  }
}
 

@Redirect(
    method = "tickNewAi",
    at = @At(
        value = "FIELD",
        target = "Lnet/minecraft/entity/mob/MobEntity;despawnCounter:I",
        opcode = Opcodes.PUTFIELD
    )
)
private void realTimeImpl$adjustForRealTimeEntityDespawnAge(final MobEntity self, final int modifier) {
    final int ticks = (int) ((RealTimeTrackingBridge) self.getEntityWorld()).realTimeBridge$getRealTimeTicks();
    this.despawnCounter += ticks;
}
 

/**
         * Visits an instance field access. The field could be of the visited class or it could be
         * an accessible field from the class being visited (unless it's private).
         * <p>
         * For private instance fields, the access instruction is rewritten to calls to reflection
         * to access the fields value:
         * <p>
         * Pseudo code for Get:
         * <code>
         *   value = $instance.fieldName;
         * </code>
         * becomes:
         * <code>
         *   value = (unbox)$package/AndroidInstantRuntime.getPrivateField($instance, $fieldName);
         * </code>
         * <p>
         * Pseudo code for Set:
         * <code>
         *   $instance.fieldName = value;
         * </code>
         * becomes:
         * <code>
         *   $package/AndroidInstantRuntime.setPrivateField($instance, value, $fieldName);
         * </code>
         *
         *
         * @param opcode the field access opcode, can only be {@link Opcodes#PUTFIELD} or
         *               {@link Opcodes#GETFIELD}
         * @param owner the field declaring class
         * @param name the field name
         * @param desc the field type
         * @param accessRight the {@link AccessRight} for the field.
         * @return true if the field access was handled or false otherwise.
         */
        private boolean visitFieldAccess(
                int opcode, String owner, String name, String desc, AccessRight accessRight) {

            // if the accessed field is anything but public, we must go through reflection.
            boolean useReflection = accessRight != AccessRight.PUBLIC;

            // if the accessed field is accessed from within a constructor, it might be a public
            // final field that cannot be set by anything but the original constructor unless
            // we use reflection.
            if (!useReflection) {
                useReflection = isConstructor && (owner.equals(visitedClassName));
            }

            if (useReflection) {
                // we should make this more efficient, have a per field access type method
                // for getting and setting field values.
                switch (opcode) {
                    case Opcodes.GETFIELD:
//                        if (DEBUG) {
                            System.out.println("Get field");
//                        }
                        // push declaring class
                        visitLdcInsn(Type.getType("L" + owner + ";"));

                        // the instance of the owner class we are getting the field value from
                        // is on top of the stack. It could be "this"
                        push(name);

                        // Stack :  <receiver>
                        //          <field_declaring_class>
                        //          <field_name>
                        invokeStatic(RUNTIME_TYPE,
                                Method.getMethod("Object getPrivateField(Object, Class, String)"));
                        // Stack : <field_value>
                        ByteCodeUtils.unbox(this, Type.getType(desc));
                        break;
                    case Opcodes.PUTFIELD:
//                        if (DEBUG) {
                            System.out.println("Set field");
//                        }
                        // the instance of the owner class we are getting the field value from
                        // is second on the stack. It could be "this"
                        // top of the stack is the new value we are trying to set, box it.
                        box(Type.getType(desc));

                        // push declaring class
                        visitLdcInsn(Type.getType("L" + owner + ";"));
                        // push the field name.
                        push(name);
                        // Stack :  <receiver>
                        //          <boxed_field_value>
                        //          <field_declaring_class>
                        //          <field_name>
                        invokeStatic(RUNTIME_TYPE,
                                Method.getMethod(
                                        "void setPrivateField(Object, Object, Class, String)"));
                        break;
                    default:
                        throw new RuntimeException(
                                "VisitFieldAccess called with wrong opcode " + opcode);
                }
                return true;
            }
            // if this is a public field, no need to change anything we can access it from the
            // $starkoverride class.
            return false;
        }
 

@Override
public void visitFieldInsn(int opcode, String owner, String name, String desc) {
    if (DEBUG) {
        System.out.println(
                "Visit field access : " + owner + ":" + name + ":" + desc + ":" + isStatic);
    }
    AccessRight accessRight;
    if (!owner.equals(visitedClassName)) {
        if (DEBUG) {
            System.out.println(owner + ":" + name + " field access");
        }
        // we are accessing another object field, and at this point the visitor is not smart
        // enough to know if has seen this class before or not so we must assume the field
        // is *not* accessible from the $override class which lives in a different
        // hierarchy and package.
        // However, since we made all package-private and protected fields public, and it
        // cannot be private since the visitedClassName is not the "owner", we can safely
        // assume it's public.
        accessRight = AccessRight.PUBLIC;
    } else {
        // check the field access bits.
        FieldNode fieldNode = getFieldByName(name);
        if (fieldNode == null) {
            // If this is an inherited field, we might not have had access to the parent
            // bytecode. In such a case, treat it as private.
            accessRight = AccessRight.PACKAGE_PRIVATE;
        } else {
            accessRight = AccessRight.fromNodeAccess(fieldNode.access);
        }
    }

    boolean handled = false;
    switch (opcode) {
        case Opcodes.PUTSTATIC:
        case Opcodes.GETSTATIC:
            handled = visitStaticFieldAccess(opcode, owner, name, desc, accessRight);
            break;
        case Opcodes.PUTFIELD:
        case Opcodes.GETFIELD:
            handled = visitFieldAccess(opcode, owner, name, desc, accessRight);
            break;
        default:
            System.out.println("Unhandled field opcode " + opcode);
    }
    if (!handled) {
        super.visitFieldInsn(opcode, owner, name, desc);
    }
}
 

@Inject(method = "render", at = @At(value = "FIELD", opcode = Opcodes.PUTFIELD, target = "Lnet/minecraft/client/gui/screen/SplashScreen;applyCompleteTime:J"))
private void onResourceReloadComplete(MatrixStack matrixStack, int mouseX, int mouseY, float delta, CallbackInfo ci) {
    ConnectionInfo.protocol.setup(true);
    ConnectionInfo.stopReloadingResources();
}
 

@Override
public void visitFieldInsn(int opcode, String owner, String internalName, String descriptor) {
    TypePool.Resolution resolution = typePool.describe(owner.replace('/', '.'));
    if (resolution.isResolved()) {
        FieldList<FieldDescription.InDefinedShape> candidates = resolution.resolve().getDeclaredFields().filter(strict
                ? ElementMatchers.<FieldDescription>named(internalName).and(hasDescriptor(descriptor))
                : ElementMatchers.<FieldDescription>failSafe(named(internalName).and(hasDescriptor(descriptor))));
        if (!candidates.isEmpty()) {
            Replacement.Binding binding = replacement.bind(instrumentedType,
                    instrumentedMethod,
                    candidates.getOnly(),
                    opcode == Opcodes.PUTFIELD || opcode == Opcodes.PUTSTATIC);
            if (binding.isBound()) {
                TypeList.Generic parameters;
                TypeDescription.Generic result;
                switch (opcode) {
                    case Opcodes.PUTFIELD:
                        parameters = new TypeList.Generic.Explicit(candidates.getOnly().getDeclaringType(), candidates.getOnly().getType());
                        result = TypeDescription.Generic.VOID;
                        break;
                    case Opcodes.PUTSTATIC:
                        parameters = new TypeList.Generic.Explicit(candidates.getOnly().getType());
                        result = TypeDescription.Generic.VOID;
                        break;
                    case Opcodes.GETFIELD:
                        parameters = new TypeList.Generic.Explicit(candidates.getOnly().getDeclaringType());
                        result = candidates.getOnly().getType();
                        break;
                    case Opcodes.GETSTATIC:
                        parameters = new TypeList.Generic.Empty();
                        result = candidates.getOnly().getType();
                        break;
                    default:
                        throw new IllegalStateException("Unexpected opcode: " + opcode);
                }
                stackSizeBuffer = Math.max(stackSizeBuffer, binding.make(parameters, result, getFreeOffset())
                        .apply(new LocalVariableTracingMethodVisitor(mv), implementationContext)
                        .getMaximalSize() - result.getStackSize().getSize());
                return;
            }
        } else if (strict) {
            throw new IllegalStateException("Could not resolve " + owner.replace('/', '.')
                    + "." + internalName + descriptor + " using " + typePool);
        }
    } else if (strict) {
        throw new IllegalStateException("Could not resolve " + owner.replace('/', '.') + " using " + typePool);
    }
    super.visitFieldInsn(opcode, owner, internalName, descriptor);
}
 

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

public void addField(ByteCodeClass cls, int opcode, String owner, String name, String desc) {
    if (cls.getOriginalClassName().equals(owner) && (opcode == Opcodes.PUTFIELD || opcode == Opcodes.PUTSTATIC)) {
        cls.addWritableField(name);
    }
    addInstruction(new Field(opcode, owner, name, desc));
}
 

@Redirect(method = "tick",
    at = @At(value = "FIELD", target = "Lnet/minecraft/entity/ItemEntity;pickupDelay:I", opcode = Opcodes.PUTFIELD, ordinal = 0))
private void realTimeImpl$adjustForRealTimePickupDelay(final ItemEntity self, final int modifier) {
    final int ticks = (int) ((RealTimeTrackingBridge) self.getEntityWorld()).realTimeBridge$getRealTimeTicks();
    this.pickupDelay = Math.max(0, this.pickupDelay - ticks);
}