org.objectweb.asm.tree.FieldInsnNode java code examples

Refine search

Common ways to obtain FieldInsnNode

private void myMethod () {
 FieldInsnNode f =String owner;String name;String descriptor;new FieldInsnNode(opcode, owner, name, descriptor)
Smart code suggestions by Codota
}

public void writePushBooleanAsMemory(boolean value) {
  if (value)
    code.add(new FieldInsnNode(
        GETSTATIC, Type.getInternalName(Memory.class), "TRUE", Type.getDescriptor(Memory.class)
    ));
  else
    code.add(new FieldInsnNode(
        GETSTATIC, Type.getInternalName(Memory.class), "FALSE", Type.getDescriptor(Memory.class)
    ));
  stackPush(Memory.Type.REFERENCE);
}

  return null;
 return loadType(loader, ((Type) cst).getClassName());
if (finsn.getOpcode() == GETSTATIC) {
 java.lang.reflect.Type possibleEnum = loadType(loader, finsn.owner);
 if (MoreTypes.getRawType(possibleEnum).isEnum()) {

int tranlocalVar = indexOfTranlocalVariable(methodNode.name, methodNode.desc);
InsnList newInstructions = new InsnList();
newInstructions.add(startLabelNode);
newInstructions.add(new LineNumberNode(debugInfo.beginLine, startLabelNode));
for (int k = 0; k < methodNode.instructions.size(); k++) {
          newInstructions.add(new MethodInsnNode(
              INVOKEVIRTUAL,
              Type.getType(AlphaTranlocal.class).getInternalName(),
              "isCommitted",
              "()Z"
        newInstructions.add(new MethodInsnNode(
            INVOKEINTERFACE,
            getInternalName(AlphaTransaction.class),
            "openForWrite",
            format("(%s)%s", getDescriptor(AlphaTransactionalObject.class), getDescriptor(AlphaTranlocal.class))));
        newInsn = new FieldInsnNode(PUTFIELD,
            ownerMetadata.getTranlocalName(),
            originalFieldInsnNode.name,
        newInstructions.add(continueGetFieldLabel);
        newInstructions.add(new FieldInsnNode(GETFIELD, ownerMetadata.getTranlocalName(), originalFieldInsnNode.name, originalFieldInsnNode.desc));

private InsnList fixInstructions(MethodNode originalMethod, CloneMap cloneMap) {
  InsnList instructions = new InsnList();
  for (int k = 0; k < originalMethod.instructions.size(); k++) {
    AbstractInsnNode originalInsn = originalMethod.instructions.get(k);
    switch (originalInsn.getOpcode()) {
        ClassMetadata ownerMetadata = metadataRepository.loadClassMetadata(classLoader, fieldInsn.owner);
        FieldMetadata fieldMetadata = ownerMetadata.getFieldMetadata(fieldInsn.name);
        Type originalFieldType = Type.getType(fieldMetadata.getDesc());
          String referenceName = Type.getType(referenceDesc).getInternalName();
          instructions.add(new FieldInsnNode(
              GETFIELD,
              fieldInsn.owner,
          instructions.add(new FieldInsnNode(
              GETFIELD,
              fieldInsn.owner,

for (Type argType : getArgumentTypes(originalMethod.desc)) {
  LocalVariableNode clonedVar = new LocalVariableNode(
      "arg" + result.localVariables.size(),
      argType.getDescriptor(),
  var += argType.getSize();
  result.localVariables.add(clonedVar);
result.instructions.add(startScope);
for (ListIterator<AbstractInsnNode> it = (ListIterator<AbstractInsnNode>) donorMethodNode.instructions.iterator(); it.hasNext();) {
  AbstractInsnNode donorInsn = it.next();
  switch (donorInsn.getOpcode()) {
        result.instructions.add(cloned);
        result.instructions.add(new FieldInsnNode(
            GETSTATIC, classNode.name, txFactoryFieldNode.name, donorFieldInsnNode.desc));
      } else {

MethodNode methodNode = methodWrapper.methodNode;
for (AbstractInsnNode insn : methodNode.instructions.toArray()) {
  if (insn instanceof MethodInsnNode) {
    MethodInsnNode methodInsnNode = (MethodInsnNode) insn;
      String newSig = isStatic ? methodInsnNode.desc : methodInsnNode.desc.replace("(",
          "(Ljava/lang/Object;");
      Type returnType = Type.getReturnType(methodInsnNode.desc);
      Type[] args = Type.getArgumentTypes(newSig);
      for (int i = 0; i < args.length; i++) {
        Type arg = args[i];
        if (arg.getSort() == Type.OBJECT) {
          args[i] = Type.getType("Ljava/lang/Object;");
      );
      methodNode.instructions.set(insn, indy);
      if (returnType.getSort() == Type.ARRAY) {
        methodNode.instructions.insert(indy, new TypeInsnNode(CHECKCAST,
            returnType.getInternalName()));
    boolean isStatic = (fieldInsnNode.getOpcode() == GETSTATIC
        || fieldInsnNode.getOpcode() == PUTSTATIC);
    boolean isSetter = (fieldInsnNode.getOpcode() == PUTFIELD
        || fieldInsnNode.getOpcode() == PUTSTATIC);
    String newSig = (isSetter) ? "(" + fieldInsnNode.desc + ")V" : "()" + fieldInsnNode.desc;
    if (!isStatic)

if (Type.getType(fieldNode.desc).equals(Type.BOOLEAN_TYPE)) {
  if (fieldNode.getOpcode() == Opcodes.PUTFIELD
      || fieldNode.getOpcode() == Opcodes.PUTSTATIC) {
    MethodInsnNode n = new MethodInsnNode(Opcodes.INVOKESTATIC,
        Type.getInternalName(BooleanHelper.class), "intToBoolean",
        Type.getMethodDescriptor(Type.BOOLEAN_TYPE,
                     new Type[] { Type.INT_TYPE }));
    TransformationStatistics.transformBackToBooleanField();
    mn.instructions.insertBefore(fieldNode, n);
  } else {
    MethodInsnNode n = new MethodInsnNode(Opcodes.INVOKESTATIC,
        Type.getMethodDescriptor(Type.INT_TYPE,
                     new Type[] { Type.BOOLEAN_TYPE }));
    mn.instructions.insert(fieldNode, n);
    TransformationStatistics.transformBackToBooleanField();
    return n;

InsnList extraInstructions = new InsnList();
for (FieldNode fieldNode : (List<FieldNode>) classNode.fields) {
  FieldMetadata fieldMetadata = classMetadata.getFieldMetadata(fieldNode.name);
    extraInstructions.add(new VarInsnNode(ALOAD, 0));
    String referenceName = Type.getType(referenceDesc).getInternalName();
    extraInstructions.add(new TypeInsnNode(NEW, referenceName));
    extraInstructions.add(new InsnNode(DUP));
        new MethodInsnNode(INVOKESPECIAL, referenceName, "<init>", "()V"));
    extraInstructions.add(new FieldInsnNode(
        PUTFIELD,
        classNode.name,

Type    ret    = Type.getReturnType(mn.desc);
InsnList nl = new InsnList();
nl.add(new VarInsnNode(Opcodes.ALOAD, 0));
nl.add(new FieldInsnNode(Opcodes.GETFIELD, iclname, AGENT_FIELD_NAME, "Ljadex/bridge/IInternalAccess;"));
nl.add(new VarInsnNode(Opcodes.ALOAD, 0));
nl.add(new FieldInsnNode(Opcodes.GETFIELD, iclname, GLOBALNAME_FIELD_NAME, "Ljava/lang/String;"));
if(ret.getClassName().equals("byte"))
  nl.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/Byte", "TYPE", "Ljava/lang/Class;"));
else if(ret.getClassName().equals("short"))
  nl.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/Short", "TYPE", "Ljava/lang/Class;"));
  nl.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/Integer", "TYPE", "Ljava/lang/Class;"));
  nl.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/Character", "TYPE", "Ljava/lang/Class;"));
  nl.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/Boolean", "TYPE", "Ljava/lang/Class;"));
  nl.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/Long", "TYPE", "Ljava/lang/Class;"));
  nl.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/Float", "TYPE", "Ljava/lang/Class;"));
  nl.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/Double", "TYPE", "Ljava/lang/Class;"));

if(name.indexOf(Type.getInternalName(IBDIAgent.class))!=-1)
    MethodNode mnode = new MethodNode(Opcodes.ACC_PUBLIC, m.getName(), Type.getMethodDescriptor(m), null, null);
    Type ret = Type.getReturnType(mnode.desc);
    InsnList nl = new InsnList();
    nl.add(new VarInsnNode(Opcodes.ALOAD, 0));
    nl.add(new FieldInsnNode(Opcodes.GETFIELD, iclname, IBDIClassGenerator.AGENT_FIELD_NAME, "Ljadex/bridge/IInternalAccess;"));
    if(m.getDeclaringClass().equals(IBDIAgentFeature.class))

Type[] args = Type.getArgumentTypes(mn.desc);
InsnList nl = new InsnList();
nl.add(new VarInsnNode(Opcodes.ALOAD, 0)); // loads the object
nl.add(new FieldInsnNode(Opcodes.GETFIELD, iclname, AGENT_FIELD_NAME, Type.getDescriptor(IInternalAccess.class)));
nl.add(new LdcInsnNode(belname));
nl.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "jadex/bdiv3/features/impl/BDIAgentFeature", "unobserveValue", 
nl.add(new VarInsnNode(Opcodes.ALOAD, 0)); // loads the agent object
nl.add(new FieldInsnNode(Opcodes.GETFIELD, iclname, AGENT_FIELD_NAME, Type.getDescriptor(IInternalAccess.class)));
nl.add(new LdcInsnNode(belname));

public void writePutDynamic(String name, Class fieldClass) {
  code.add(new FieldInsnNode(
      PUTFIELD,
      method.clazz.node.name,
      name,
      Type.getDescriptor(fieldClass)
  ));
  stackPop();
}

@SuppressWarnings( {"unchecked"})
private void generateGetFromCache() {
  Type[] paramTypes = Type.getArgumentTypes(method.desc);
  cacheFieldName = findUnusedCacheFieldName();
  insert(new FieldInsnNode(GETFIELD, classNode.name, cacheFieldName, cacheFieldDesc));
  insert(new FieldInsnNode(PUTFIELD, classNode.name, cacheFieldName, cacheFieldDesc));
  if (paramTypes.length > 1 || paramTypes[0].getSort() == Type.ARRAY) {
    String arguments = Type.getInternalName(Arguments.class);

  List<Mutation> mutations) {
InsnList instructions = new InsnList();
  instructions.add(mutation.getInfectionDistance());
  instructions.add(new LdcInsnNode(mutation.getId()));
  MethodInsnNode touched = new MethodInsnNode(Opcodes.INVOKESTATIC,
      Type.getInternalName(ExecutionTracer.class), "passedMutation",
      Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] {
          Type.DOUBLE_TYPE, Type.INT_TYPE }), false);
  instructions.add(touched);
  instructions.add(mutationId);
  FieldInsnNode activeId = new FieldInsnNode(Opcodes.GETSTATIC,
      Type.getInternalName(MutationObserver.class), "activeMutation", "I");
  instructions.add(activeId);
  instructions.add(new JumpInsnNode(Opcodes.IF_ICMPNE, nextLabel));

private void addCaptureEnableStatement(final String className, final MethodNode mn, final InsnList il, final int returnValueVar)
  il.add(new LdcInsnNode(this.captureId));
    il.add(new LdcInsnNode(className));
    il.add(new MethodInsnNode(Opcodes.INVOKESTATIC,
        PackageInfo.getNameWithSlash(CaptureUtil.class),
         "loadClass", 
  final Type returnType = Type.getReturnType(mn.desc);
  if(returnType.equals(Type.VOID_TYPE))
    il.add(new FieldInsnNode(Opcodes.GETSTATIC, PackageInfo.getNameWithSlash(CaptureLog.class),
                 "RETURN_TYPE_VOID", 
                 Type.getDescriptor(Object.class)));

InsnList toInject = new InsnList();
LabelNode ifNotCanceled = new LabelNode();
toInject.add(new VarInsnNode(Opcodes.ALOAD, 1));
toInject.add(new VarInsnNode(Opcodes.ALOAD, 2));
toInject.add(new VarInsnNode(Opcodes.ALOAD, 3));
toInject.add(new VarInsnNode(Opcodes.ILOAD, 4));
toInject.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(Hooks.class), "onFlowIntoBlock", "(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/state/IBlockState;I)Z", false));
toInject.add(new JumpInsnNode(Opcodes.IFEQ, ifNotCanceled));
toInject.add(new InsnNode(Opcodes.RETURN));
InsnList toInject = new InsnList();
toInject.add(new VarInsnNode(Opcodes.ALOAD, 0));
toInject.add(new FieldInsnNode(Opcodes.GETFIELD, isObfuscated ? "aqk" : "net/minecraft/tileentity/TileEntity", isObfuscated ? "b" : "worldObj", isObfuscated ? "Laid;" : "Lnet/minecraft/world/World;"));
toInject.add(new VarInsnNode(Opcodes.ALOAD, 0));
toInject.add(new FieldInsnNode(Opcodes.GETFIELD, isObfuscated ? "aqk" : "net/minecraft/tileentity/TileEntity", isObfuscated ? "c" : "pos", isObfuscated ? "Lcm;" : "Lnet/minecraft/util/math/BlockPos;"));
toInject.add(new VarInsnNode(Opcodes.ALOAD, 0));
toInject.add(new FieldInsnNode(Opcodes.GETFIELD, isObfuscated ? "arm" : "net/minecraft/tileentity/TileEntityPiston", isObfuscated ? "i" : "progress", "F"));
toInject.add(new VarInsnNode(Opcodes.ALOAD, 0));
toInject.add(new FieldInsnNode(Opcodes.GETFIELD, isObfuscated ? "arm" : "net/minecraft/tileentity/TileEntityPiston", isObfuscated ? "g" : "extending", "Z"));
toInject.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(Hooks.class), "onPistonTileUpdate", "(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;FZ)V", false));
method.instructions.insertBefore(findFirstInstruction(method), toInject);
toInject.add(new VarInsnNode(Opcodes.ALOAD, 3));
toInject.add(new VarInsnNode(Opcodes.ILOAD, 4));
toInject.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(Hooks.class), "onPistonMove", "(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/util/EnumFacing;Z)V", false));
method.instructions.insertBefore(findFirstInstruction(method), toInject);

public static AbstractInsnNode loadBoxedBoolean(boolean value) {
  return new FieldInsnNode(
      GETSTATIC,
      Type.getInternalName(Boolean.class),
      value ? "TRUE" : "FALSE",
      Type.getDescriptor(Boolean.class));
}

protected void convertXLoads(InstructionGroup group) {
  String owner = group.getGroupClassType().getInternalName();
  for (InstructionGraphNode node : group.getNodes()) {
    if (!node.isXLoad()) continue;
    VarInsnNode insn = (VarInsnNode) node.getInstruction();
    FieldNode field = group.getFields().get(insn.var);
    // insert the correct GETFIELD after the xLoad
    group.getInstructions().insert(insn, new FieldInsnNode(GETFIELD, owner, field.name, field.desc));
    // change the load to ALOAD 0
    group.getInstructions().set(insn, new VarInsnNode(ALOAD, 0));
  }
}

newInstructions.add(new InsnNode(DUP));
newInstructions.add(new InsnNode(DUP));
newInstructions.add(new FieldInsnNode(GETFIELD, CLASS_MOVE_EVENT, "type", "L" + CLASS_MOVER_TYPE + ";"));
newInstructions.add(new VarInsnNode(ASTORE, 1));
newInstructions.add(new FieldInsnNode(GETFIELD, CLASS_MOVE_EVENT, "x", "D"));
newInstructions.add(new VarInsnNode(DSTORE, 2));
newInstructions.add(new FieldInsnNode(GETFIELD, CLASS_MOVE_EVENT, "y", "D"));
newInstructions.add(new VarInsnNode(DSTORE, 4));
newInstructions.add(new FieldInsnNode(GETFIELD, CLASS_MOVE_EVENT, "z", "D"));
newInstructions.add(new VarInsnNode(DSTORE, 6));
newInstructions.add(new InsnNode(DUP));
newInstructions.add(new InsnNode(DUP));
newInstructions.add(new FieldInsnNode(GETFIELD, CLASS_TRAVEL_EVENT, "strafe", "F"));
newInstructions.add(new VarInsnNode(FSTORE, 1));
newInstructions.add(new FieldInsnNode(GETFIELD, CLASS_TRAVEL_EVENT, "vertical", "F"));
newInstructions.add(new VarInsnNode(FSTORE, 2));
newInstructions.add(new FieldInsnNode(GETFIELD, CLASS_TRAVEL_EVENT, "forward", "F"));
newInstructions.add(new VarInsnNode(FSTORE, 3));
  if (insnNode instanceof FieldInsnNode) {
    FieldInsnNode fInsnNode = (FieldInsnNode) insnNode;
    if (fInsnNode.getOpcode() == Opcodes.PUTFIELD
        && fInsnNode.owner.equals(CLASS_ENTITY_PLAYER)
        && equalsEither(fInsnNode.name, "field_70145_X", "noClip")

@Override
public void visitFieldInsn(
  final int opcode, final String owner, final String name, final String descriptor) {
 instructions.add(new FieldInsnNode(opcode, owner, name, descriptor));
}

Javadoc

A node that represents a field instruction. A field instruction is an instruction that loads or stores the value of a field of an object.

Most used methods

Popular in Java

Creating JSON documents from java classes using gson
onRequestPermissionsResult (Fragment)
putExtra (Intent)
getContentResolver (Context)
GridLayout (java.awt)
The GridLayout class is a layout manager that lays out a container's components in a rectangular gri
EOFException (java.io)
Thrown when a program encounters the end of a file or stream during an input operation.
File (java.io)
An "abstract" representation of a file system entity identified by a pathname. The pathname may be a
URLConnection (java.net)
The abstract class URLConnection is the superclass of all classes that represent a communications li
SortedSet (java.util)
A Set that further provides a total ordering on its elements. The elements are ordered using their C
Option (scala)

How to useFieldInsnNode in org.objectweb.asm.tree

Best Java code snippets using org.objectweb.asm.tree.FieldInsnNode (Showing top 20 results out of 315)

Refine search

How to use
FieldInsnNode
in
org.objectweb.asm.tree