org.jf.dexlib2.iface.reference.FieldReference Java Examples

private int getNextFieldOffset() {
    SparseArray<FieldReference> instanceFields = getInstanceFields();
    if (instanceFields.size() == 0) {
        return 8;
    }

    int lastItemIndex = instanceFields.size()-1;
    int fieldOffset = instanceFields.keyAt(lastItemIndex);
    FieldReference lastField = instanceFields.valueAt(lastItemIndex);

    switch (lastField.getType().charAt(0)) {
        case 'J':
        case 'D':
            return fieldOffset + 8;
        default:
            return fieldOffset + 4;
    }
}
 

public static void writeReference(IndentingWriter writer, int referenceType,
                                  Reference reference) throws IOException {
    switch (referenceType) {
        case ReferenceType.STRING:
            writeStringReference(writer, ((StringReference)reference).getString());
            return;
        case ReferenceType.TYPE:
            writer.write(((TypeReference)reference).getType());
            return;
        case ReferenceType.METHOD:
            ReferenceUtil.writeMethodDescriptor(writer, (MethodReference) reference);
            return;
        case ReferenceType.FIELD:
            ReferenceUtil.writeFieldDescriptor(writer, (FieldReference)reference);
            return;
        default:
            throw new IllegalStateException("Unknown reference type");
    }
}
 

public void jimplify (DexBody body) {
      int dest = ((OneRegisterInstruction)instruction).getRegisterA();
      FieldReference f = (FieldReference)((ReferenceInstruction)instruction).getReference();
      StaticFieldRef r = Jimple.v().newStaticFieldRef(getStaticSootFieldRef(f));
      assign = Jimple.v().newAssignStmt(body.getRegisterLocal(dest), r);
      setUnit(assign);
      addTags(assign);
      body.add(assign);
      
if (IDalvikTyper.ENABLE_DVKTYPER) {
	Debug.printDbg(IDalvikTyper.DEBUG, "constraint: "+ assign);
        int op = (int)instruction.getOpcode().value;
        DalvikTyper.v().setType(assign.getLeftOpBox(), r.getType(), false);
      }
  }
 

public void intern(@Nonnull FieldReference field) {
    Integer prev = internedItems.put(field, 0);
    if (prev == null) {
        typePool.intern(field.getDefiningClass());
        stringPool.intern(field.getName());
        typePool.intern(field.getType());
    }
}
 

public void intern(@Nonnull FieldReference field) {
    Integer prev = internedItems.put(field, 0);
    if (prev == null) {
        typePool.intern(field.getDefiningClass());
        stringPool.intern(field.getName());
        typePool.intern(field.getType());
    }
}
 

@Override
public int compareTo(@Nonnull FieldReference o) {
    int res = getDefiningClass().compareTo(o.getDefiningClass());
    if (res != 0) return res;
    res = getName().compareTo(o.getName());
    if (res != 0) return res;
    return getType().compareTo(o.getType());
}
 

@Override
public Set<Type> introducedTypes() {
    Set<Type> types = new HashSet<Type>();
    // Aput instructions don't have references
    if (!(instruction instanceof ReferenceInstruction))
        return types;

    ReferenceInstruction i = (ReferenceInstruction) instruction;

    FieldReference field = (FieldReference) i.getReference();

    types.add(DexType.toSoot(field.getType()));
    types.add(DexType.toSoot(field.getDefiningClass()));
    return types;
}
 

@Nonnull public BuilderFieldReference internField(@Nonnull FieldReference fieldReference) {
    BuilderFieldReference ret = internedItems.get(fieldReference);
    if (ret != null) {
        return ret;
    }

    BuilderFieldReference dexPoolFieldReference = new BuilderFieldReference(
            context.typePool.internType(fieldReference.getDefiningClass()),
            context.stringPool.internString(fieldReference.getName()),
            context.typePool.internType(fieldReference.getType()));
    ret = internedItems.putIfAbsent(dexPoolFieldReference, dexPoolFieldReference);
    return ret==null?dexPoolFieldReference:ret;
}
 

@Override
@Nullable
public FieldReference getFieldByOffset(int fieldOffset) {
    if (getInstanceFields().size() == 0) {
        return null;
    }
    return getInstanceFields().get(fieldOffset);
}
 

@Override @Nonnull public Reference getReference() {
    switch (getReferenceType()) {
        case ReferenceType.TYPE:
            return RewriterUtils.rewriteTypeReference(rewriters.getTypeRewriter(),
                    (TypeReference)instruction.getReference());
        case ReferenceType.FIELD:
            return rewriters.getFieldReferenceRewriter().rewrite((FieldReference)instruction.getReference());
        case ReferenceType.METHOD:
            return rewriters.getMethodReferenceRewriter().rewrite((MethodReference)instruction.getReference());
        case ReferenceType.STRING:
            return instruction.getReference();
        default:
            throw new IllegalArgumentException();
    }
}
 

private void analyzeIgetSgetWideObject(@Nonnull AnalyzedInstruction analyzedInstruction) {
    ReferenceInstruction referenceInstruction = (ReferenceInstruction)analyzedInstruction.instruction;

    FieldReference fieldReference = (FieldReference)referenceInstruction.getReference();

    RegisterType fieldType = RegisterType.getRegisterType(classPath, fieldReference.getType());
    setDestinationRegisterTypeAndPropagateChanges(analyzedInstruction, fieldType);
}
 

@Override
@Nullable
public FieldReference getFieldByOffset(int fieldOffset) {
    if (fieldOffset==8) {
        return new ImmutableFieldReference(getType(), "length", "int");
    }
    return null;
}
 

@Nonnull static <StringRef extends StringReference, TypeRef extends TypeReference, FieldRefKey extends FieldReference, MethodRefKey extends MethodReference>
        InstructionWriter<StringRef, TypeRef, FieldRefKey, MethodRefKey>
        makeInstructionWriter(
            @Nonnull DexDataWriter writer,
            @Nonnull StringSection<?, StringRef> stringSection,
            @Nonnull TypeSection<?, ?, TypeRef> typeSection,
            @Nonnull FieldSection<?, ?, FieldRefKey, ?> fieldSection,
            @Nonnull MethodSection<?, ?, ?, MethodRefKey, ?> methodSection) {
    return new InstructionWriter<StringRef, TypeRef, FieldRefKey, MethodRefKey>(
            writer, stringSection, typeSection, fieldSection, methodSection);
}
 

private void analyzeIgetSgetWideObject(@Nonnull AnalyzedInstruction analyzedInstruction) {
    ReferenceInstruction referenceInstruction = (ReferenceInstruction)analyzedInstruction.instruction;

    FieldReference fieldReference = (FieldReference)referenceInstruction.getReference();

    RegisterType fieldType = RegisterType.getRegisterType(classPath, fieldReference.getType());
    setDestinationRegisterTypeAndPropagateChanges(analyzedInstruction, fieldType);
}
 

@Override
public boolean equals(@Nullable Object o) {
    if (o instanceof FieldReference) {
        FieldReference other = (FieldReference)o;
        return getDefiningClass().equals(other.getDefiningClass()) &&
               getName().equals(other.getName()) &&
               getType().equals(other.getType());

    }
    return false;
}
 

public void intern(@Nonnull FieldReference field) {
    Integer prev = internedItems.put(field, 0);
    if (prev == null) {
        typePool.intern(field.getDefiningClass());
        stringPool.intern(field.getName());
        typePool.intern(field.getType());
    }
}
 

@Nonnull
public static ImmutableFieldReference of(@Nonnull FieldReference fieldReference) {
    if (fieldReference instanceof ImmutableFieldReference) {
        return (ImmutableFieldReference)fieldReference;
    }
    return new ImmutableFieldReference(
            fieldReference.getDefiningClass(),
            fieldReference.getName(),
            fieldReference.getType());
}
 

@Override
public int compareTo(@Nonnull FieldReference o) {
    int res = getDefiningClass().compareTo(o.getDefiningClass());
    if (res != 0) return res;
    res = getName().compareTo(o.getName());
    if (res != 0) return res;
    return getType().compareTo(o.getType());
}
 

@Override
public int compareTo(@Nonnull FieldReference o) {
    int res = getDefiningClass().compareTo(o.getDefiningClass());
    if (res != 0) return res;
    res = getName().compareTo(o.getName());
    if (res != 0) return res;
    return getType().compareTo(o.getType());
}
 

@Nonnull static <StringRef extends StringReference, TypeRef extends TypeReference, FieldRefKey extends FieldReference, MethodRefKey extends MethodReference>
        InstructionWriter<StringRef, TypeRef, FieldRefKey, MethodRefKey>
        makeInstructionWriter(
            @Nonnull DexDataWriter writer,
            @Nonnull StringSection<?, StringRef> stringSection,
            @Nonnull TypeSection<?, ?, TypeRef> typeSection,
            @Nonnull FieldSection<?, ?, FieldRefKey, ?> fieldSection,
            @Nonnull MethodSection<?, ?, ?, MethodRefKey, ?> methodSection) {
    return new InstructionWriter<StringRef, TypeRef, FieldRefKey, MethodRefKey>(
            writer, stringSection, typeSection, fieldSection, methodSection);
}
 

public void intern(@Nonnull FieldReference field) {
    Integer prev = internedItems.put(field, 0);
    if (prev == null) {
        typePool.intern(field.getDefiningClass());
        stringPool.intern(field.getName());
        typePool.intern(field.getType());
    }
}
 

@Nonnull public BuilderFieldReference internField(@Nonnull FieldReference fieldReference) {
    BuilderFieldReference ret = internedItems.get(fieldReference);
    if (ret != null) {
        return ret;
    }

    BuilderFieldReference dexPoolFieldReference = new BuilderFieldReference(
            context.typePool.internType(fieldReference.getDefiningClass()),
            context.stringPool.internString(fieldReference.getName()),
            context.typePool.internType(fieldReference.getType()));
    ret = internedItems.putIfAbsent(dexPoolFieldReference, dexPoolFieldReference);
    return ret==null?dexPoolFieldReference:ret;
}
 

@Override @Nonnull public Reference getReference() {
    switch (getReferenceType()) {
        case ReferenceType.TYPE:
            return RewriterUtils.rewriteTypeReference(rewriters.getTypeRewriter(),
                    (TypeReference)instruction.getReference());
        case ReferenceType.FIELD:
            return rewriters.getFieldReferenceRewriter().rewrite((FieldReference)instruction.getReference());
        case ReferenceType.METHOD:
            return rewriters.getMethodReferenceRewriter().rewrite((MethodReference)instruction.getReference());
        case ReferenceType.STRING:
            return instruction.getReference();
        default:
            throw new IllegalArgumentException();
    }
}
 

@Nonnull static <StringRef extends StringReference, TypeRef extends TypeReference, FieldRefKey extends FieldReference, MethodRefKey extends MethodReference>
        InstructionWriter<StringRef, TypeRef, FieldRefKey, MethodRefKey>
        makeInstructionWriter(
            @Nonnull DexDataWriter writer,
            @Nonnull StringSection<?, StringRef> stringSection,
            @Nonnull TypeSection<?, ?, TypeRef> typeSection,
            @Nonnull FieldSection<?, ?, FieldRefKey, ?> fieldSection,
            @Nonnull MethodSection<?, ?, ?, MethodRefKey, ?> methodSection) {
    return new InstructionWriter<StringRef, TypeRef, FieldRefKey, MethodRefKey>(
            writer, stringSection, typeSection, fieldSection, methodSection);
}
 

@Override
@Nullable
public FieldReference getFieldByOffset(int fieldOffset) {
    if (fieldOffset==8) {
        return new ImmutableFieldReference(getType(), "length", "int");
    }
    return null;
}
 

@Nonnull public BuilderFieldReference internField(@Nonnull FieldReference fieldReference) {
    BuilderFieldReference ret = internedItems.get(fieldReference);
    if (ret != null) {
        return ret;
    }

    BuilderFieldReference dexPoolFieldReference = new BuilderFieldReference(
            context.typePool.internType(fieldReference.getDefiningClass()),
            context.stringPool.internString(fieldReference.getName()),
            context.typePool.internType(fieldReference.getType()));
    ret = internedItems.putIfAbsent(dexPoolFieldReference, dexPoolFieldReference);
    return ret==null?dexPoolFieldReference:ret;
}
 

protected static BuilderFieldReference toFieldReference
   		(SootField f, DexBuilder belongingDexFile) {
   	FieldReference fieldRef = new ImmutableFieldReference
   			(SootToDexUtils.getDexClassName(f.getDeclaringClass().getName()),
   			f.getName(),
   			SootToDexUtils.getDexTypeDescriptor(f.getType()));
   	return belongingDexFile.internFieldReference(fieldRef);
}
 

/**
 * Return a SootFieldRef for a dexlib FieldReference.
 *
 * @param item the dexlib FieldReference.
 * @param isStatic if the FieldRef should be static
 */
private SootFieldRef getSootFieldRef(FieldReference fref, boolean isStatic) {
    String className = dottedClassName(fref.getDefiningClass());
    SootClass sc = SootResolver.v().makeClassRef(className);
    return Scene.v().makeFieldRef(sc,
                                  fref.getName(),
                                  DexType.toSoot(fref.getType()),
                                  isStatic);
}
 

public RewrittenFieldReference(@Nonnull FieldReference fieldReference) {
    this.fieldReference = fieldReference;
}
 

public RewrittenFieldReference(@Nonnull FieldReference fieldReference) {
    this.fieldReference = fieldReference;
}