Java Code Examples for org.objectweb.asm.Opcodes#PUTSTATIC
The following examples show how to use
org.objectweb.asm.Opcodes#PUTSTATIC .
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
| Source File: InstructionAdapter.java From JReFrameworker with MIT License | 6 votes |
|
@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();
}
}
Example 2
| Source File: MethodVisitorBuilder.java From testability-explorer with Apache License 2.0 | 6 votes |
|
public void visitFieldInsn(final int opcode, String owner,
final String name, final String desc) {
owner = namer.nameClass(owner);
switch (opcode) {
case Opcodes.PUTSTATIC :
recorder.add(new PutFieldRunnable(repository, owner, name, desc, true));
break;
case Opcodes.PUTFIELD :
recorder.add(new PutFieldRunnable(repository, owner, name, desc, false));
break;
case Opcodes.GETSTATIC :
recorder.add(new GetFieldRunnable(repository, owner, name, desc, true));
break;
case Opcodes.GETFIELD :
recorder.add(new GetFieldRunnable(repository, owner, name, desc, false));
break;
}
}
Example 3
| Source File: BytecodeTypeInference.java From bazel with Apache License 2.0 | 6 votes |
|
@Override
public void visitFieldInsn(int opcode, String owner, String name, String desc) {
switch (opcode) {
case Opcodes.GETSTATIC:
pushDescriptor(desc);
break;
case Opcodes.PUTSTATIC:
popDescriptor(desc);
break;
case Opcodes.GETFIELD:
pop();
pushDescriptor(desc);
break;
case Opcodes.PUTFIELD:
popDescriptor(desc);
pop();
break;
default:
throw new RuntimeException(
"Unhandled opcode " + opcode + ", owner=" + owner + ", name=" + name + ", desc" + desc);
}
super.visitFieldInsn(opcode, owner, name, desc);
}
Example 4
| Source File: StateTrackingMethodVisitor.java From scott with MIT License | 6 votes |
|
@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;
}
}
}
Example 5
| Source File: AccessorGeneratorFieldSetter.java From Mixin with MIT License | 6 votes |
|
@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;
}
Example 6
| Source File: ClassParserUsingASM.java From spotbugs with GNU Lesser General Public License v2.1 | 6 votes |
|
@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();
}
Example 7
| Source File: InstructionAdapter.java From JByteMod-Beta with GNU General Public License v2.0 | 6 votes |
|
@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();
}
}
Example 8
| Source File: StringEncryptionTransformer.java From deobfuscator with Apache License 2.0 | 6 votes |
|
private boolean isSmokeMethod(MethodNode method)
{
boolean containsArray = false;
int putstatic = 0;
int getstatic = 0;
for(AbstractInsnNode ain : method.instructions.toArray())
if(ain.getOpcode() == Opcodes.ANEWARRAY)
containsArray = true;
else if(ain.getOpcode() == Opcodes.PUTSTATIC || ain.getOpcode() == Opcodes.GETSTATIC)
if(((FieldInsnNode)ain).desc.equals("[Ljava/lang/String;"))
{
if(ain.getOpcode() == Opcodes.PUTSTATIC)
putstatic++;
else
getstatic++;
}
return containsArray && putstatic == 2 && getstatic == 2;
}
Example 9
| Source File: SerianalyzerMethodVisitor.java From serianalyzer with GNU General Public License v3.0 | 6 votes |
|
/**
* {@inheritDoc}
*
* @see org.objectweb.asm.MethodVisitor#visitFieldInsn(int, java.lang.String, java.lang.String, java.lang.String)
*/
@Override
public void visitFieldInsn ( int opcode, String owner, String name, String desc ) {
JVMStackState s = this.stack;
if ( opcode == Opcodes.PUTSTATIC ) {
Object v = s.pop();
if ( ! ( v instanceof BaseType ) || ( (BaseType) v ).isTainted() ) {
// generated static cached, let's assume they are safe
if ( name.indexOf('$') < 0 && this.ref.getMethod().indexOf('$') < 0 ) {
this.parent.getAnalyzer().putstatic(this.ref);
}
}
}
else {
JVMImpl.handleFieldInsn(opcode, owner, name, desc, s);
}
if ( ( opcode == Opcodes.GETSTATIC || opcode == Opcodes.GETFIELD ) && name.indexOf('$') < 0 ) {
this.parent.getAnalyzer().instantiable(this.ref, Type.getType(desc));
}
super.visitFieldInsn(opcode, owner, name, desc);
}
Example 10
| Source File: InstructionAdapter.java From JReFrameworker with MIT License | 6 votes |
|
@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();
}
}
Example 11
| Source File: StaticLambdaAndGraphBuilder.java From Concurnas with MIT License | 5 votes |
|
public void visitFieldInsn(final int opcode, final String owner, final String name, final String descriptor) {
if (opcode == Opcodes.GETSTATIC || opcode == Opcodes.PUTSTATIC) {
if(!owner.equals(me.myName)) {
getNode(owner).nodesDependingOnMyStaticFields.add(this.instx);
}else if(!localfields.contains(name + descriptor)){
//if owner is myname but field is not defined in class, find where it is defined
String origin = findLocationOfField(name, descriptor, superName, interfaces);
if(null != origin) {//include source of field and intermediate classes for inclusion.. TODO: remove, not used
Pair<ClassNode, Boolean> intermia = new Pair<ClassNode, Boolean>(this.instx.getA(), true);
getNode(origin).nodesDependingOnMyStaticFields.add(intermia);
}
}
}
}
Example 12
| Source File: InterfaceDesugaring.java From bazel with Apache License 2.0 | 5 votes |
|
@Override
public void visitFieldInsn(int opcode, String owner, String name, String desc) {
if (interfaceFieldToAccessInCompanionMethodToTriggerInterfaceClinit == null
&& opcode == Opcodes.PUTSTATIC
&& owner.equals(internalName)) {
// It is possible that an interface initializer can sets fields of other classes.
// (b/64290760), so we test whether the owner is the same as the internalName.
interfaceFieldToAccessInCompanionMethodToTriggerInterfaceClinit =
FieldInfo.create(owner, name, desc);
}
super.visitFieldInsn(opcode, owner, name, desc);
}
Example 13
| Source File: RedirectInjector.java From Mixin with MIT License | 5 votes |
|
RedirectedFieldData(Target target, FieldInsnNode node) {
super(target);
this.node = node;
this.opcode = node.getOpcode();
this.owner = Type.getObjectType(node.owner);
this.type = Type.getType(node.desc);
this.dimensions = (this.type.getSort() == Type.ARRAY) ? this.type.getDimensions() : 0;
this.isStatic = this.opcode == Opcodes.GETSTATIC || this.opcode == Opcodes.PUTSTATIC;
this.isGetter = this.opcode == Opcodes.GETSTATIC || this.opcode == Opcodes.GETFIELD;
this.isSetter = this.opcode == Opcodes.PUTSTATIC || this.opcode == Opcodes.PUTFIELD;
this.description = this.isGetter ? "field getter" : this.isSetter ? "field setter" : "handler";
}
Example 14
| Source File: FieldHandler.java From native-obfuscator with GNU General Public License v3.0 | 5 votes |
|
@Override
protected void process(MethodContext context, FieldInsnNode node) {
boolean isStatic = node.getOpcode() == Opcodes.GETSTATIC || node.getOpcode() == Opcodes.PUTSTATIC;
CachedFieldInfo info = new CachedFieldInfo(node.owner, node.name, node.desc, isStatic);
instructionName += "_" + Type.getType(node.desc).getSort();
if (isStatic) {
props.put("class_ptr", context.getCachedClasses().getPointer(node.owner));
}
int classId = context.getCachedClasses().getId(node.owner);
context.output.append(String.format("if (!cclasses[%d] || env->IsSameObject(cclasses[%d], NULL)) { cclasses_mtx[%d].lock(); if (!cclasses[%d] || env->IsSameObject(cclasses[%d], NULL)) { if (jclass clazz = %s) { cclasses[%d] = (jclass) env->NewWeakGlobalRef(clazz); env->DeleteLocalRef(clazz); } } cclasses_mtx[%d].unlock(); %s } ",
classId,
classId,
classId,
classId,
classId,
MethodProcessor.getClassGetter(context, node.owner),
classId,
classId,
trimmedTryCatchBlock));
int fieldId = context.getCachedFields().getId(info);
props.put("fieldid", context.getCachedFields().getPointer(info));
context.output.append(String.format("if (!cfields[%d]) { cfields[%d] = env->Get%sFieldID(%s, %s, %s); %s } ",
fieldId,
fieldId,
isStatic ? "Static" : "",
context.getCachedClasses().getPointer(node.owner),
context.getStringPool().get(node.name),
context.getStringPool().get(node.desc),
trimmedTryCatchBlock));
}
Example 15
| Source File: IncrementalChangeVisitor.java From AnoleFix with MIT License | 4 votes |
|
/**
* Static field access visit.
* So far we do not support class initializer "clinit" that would reset the static field
* value in the class newer versions. Think about the case, where a static initializer
* resets a static field value, we don't know if the current field value was set through
* the initial class initializer or some code path, should we change the field value to the
* new one ?
* <p>
* For private static fields, the access instruction is rewritten to calls to reflection
* to access the fields value:
* <p/>
* Pseudo code for Get:
* <code>
* value = $type.fieldName;
* </code>
* becomes:
* <code>
* value = (unbox)$package/AndroidInstantRuntime.getStaticPrivateField(
* $type.class, $fieldName);
* </code>
* <p/>
* Pseudo code for Set:
* <code>
* $type.fieldName = value;
* </code>
* becomes:
* <code>
* $package/AndroidInstantRuntime.setStaticPrivateField(value, $type.class $fieldName);
* </code>
*
* @param opcode the field access opcode, can only be {@link Opcodes#PUTSTATIC} or
* {@link Opcodes#GETSTATIC}
* @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
*/
private boolean visitStaticFieldAccess(
int opcode, String owner, String name, String desc, AccessRight accessRight) {
if (accessRight != AccessRight.PUBLIC) {
switch (opcode) {
case Opcodes.GETSTATIC:
if (DEBUG) {
System.out.println("Get static field " + name);
}
// nothing of interest is on the stack.
visitLdcInsn(Type.getType("L" + owner + ";"));
push(name);
// Stack : <target_class>
// <field_name>
invokeStatic(RUNTIME_TYPE,
Method.getMethod("Object getStaticPrivateField(Class, String)"));
// Stack : <field_value>
ByteCodeUtils.unbox(this, Type.getType(desc));
return true;
case Opcodes.PUTSTATIC:
if (DEBUG) {
System.out.println("Set static field " + name);
}
// the new field value is on top of the stack.
// box it into an Object.
box(Type.getType(desc));
visitLdcInsn(Type.getType("L" + owner + ";"));
push(name);
// Stack : <boxed_field_value>
// <target_class>
// <field_name>
invokeStatic(RUNTIME_TYPE,
Method.getMethod(
"void setStaticPrivateField(Object, Class, String)"));
return true;
default:
throw new RuntimeException(
"VisitStaticFieldAccess called with wrong opcode " + opcode);
}
}
return false;
}
Example 16
| Source File: IncrementalChangeVisitor.java From AnoleFix with MIT License | 4 votes |
|
@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);
}
}
Example 17
| Source File: AllocateInstrument.java From dacapobench with Apache License 2.0 | 4 votes |
|
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);
}
Example 18
| Source File: FingerprintUtil.java From java-specialagent with Apache License 2.0 | 4 votes |
|
static boolean isPutStatic(final int mod) {
return (mod & Opcodes.PUTSTATIC) != 0;
}
Example 19
| Source File: BytecodeMethod.java From CodenameOne with GNU General Public License v2.0 | 4 votes |
|
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));
}
Example 20
| Source File: MemberSubstitution.java From byte-buddy with Apache License 2.0 | 4 votes |
|
@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);
}
