boolean isCurrentDexHasChangedClass = false; for (org.jf.dexlib2.iface.ClassDef classDef : dexFile.getClasses()) { if (descOfChangedClassesInCurrDex.contains(classDef.getType())) { isCurrentDexHasChangedClass = true; break; if (!descOfChangedClassesInCurrDex.contains(classDef.getType())) { continue; Logger.d("Class %s will be added into changed classes dex ...", classDef.getType()); for (Field field : classDef.getFields()) { final BuilderField builderField = dexBuilder.internField( field.getDefiningClass(), for (Method method : classDef.getMethods()) { MethodImplementation methodImpl = method.getImplementation(); if (methodImpl != null) { classDef.getType(), classDef.getAccessFlags(), classDef.getSuperclass(), classDef.getInterfaces(), classDef.getSourceFile(), classDef.getAnnotations(), builderFields, builderMethods
public Dependencies makeSootClass(SootClass sc, ClassDef defItem, DexFile dexFile) { String superClass = defItem.getSuperclass(); Dependencies deps = new Dependencies(); String sourceFile = defItem.getSourceFile(); if (sourceFile != null) { sc.addTag(new SourceFileTag(sourceFile)); int accessFlags = defItem.getAccessFlags(); sc.setModifiers(accessFlags); if (defItem.getInterfaces() != null) { for (String interfaceName : defItem.getInterfaces()) { String interfaceClassName = Util.dottedClassName(interfaceName); if (sc.implementsInterface(interfaceClassName)) { for (Field sf : defItem.getStaticFields()) { loadField(sc, da, sf); for (Field f : defItem.getInstanceFields()) { loadField(sc, da, f); for (Method method : defItem.getDirectMethods()) { loadMethod(method, sc, da, dexMethod); for (Method method : defItem.getVirtualMethods()) { loadMethod(method, sc, da, dexMethod);
public byte[] build(ClassDef classDef) { log.debug("Building input class: {}", classDef); ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS); visitClass(classDef, classWriter); visitFields(classDef.getFields(), classWriter, classDef.getAccessFlags()); if ((classDef.getAccessFlags() & Opcodes.ACC_ENUM) != 0) { visitEnumMethods(classDef, classDef.getFields(), classWriter); } else { visitMethods(classDef, classDef.getMethods(), classWriter); } classWriter.visitEnd(); return classWriter.toByteArray(); }
private void visitClass(ClassDef classDef, ClassWriter classWriter) { int version = Opcodes.V1_8; int access = classDef.getAccessFlags(); String name = stripName(classDef.getType()); // Signature should be type signature for the class, which is uncommon. String signature = buildASMSignature(classDef); String superName = null; if (classDef.getSuperclass() != null) { superName = stripName(classDef.getSuperclass()); } String[] interfaces = buildInterfaces(classDef); classWriter.visit(version, access, name, signature, superName, interfaces); classWriter.visitSource(classDef.getSourceFile(), null); visitClassAnnotations(classDef.getAnnotations(), classWriter); }
PoolClassDef(@Nonnull ClassDef classDef) { this.classDef = classDef; interfaces = new TypeListPool.Key<List<String>>(ImmutableList.copyOf(classDef.getInterfaces())); staticFields = ImmutableSortedSet.copyOf(classDef.getStaticFields()); instanceFields = ImmutableSortedSet.copyOf(classDef.getInstanceFields()); directMethods = ImmutableSortedSet.copyOf( Iterables.transform(classDef.getDirectMethods(), PoolMethod.TRANSFORM)); virtualMethods = ImmutableSortedSet.copyOf( Iterables.transform(classDef.getVirtualMethods(), PoolMethod.TRANSFORM)); }
Set<? extends Annotation> aSet = classDef.getAnnotations(); if (aSet == null || aSet.isEmpty()) { return; List<Tag> tags = handleAnnotation(aSet, classDef.getType()); if (tags == null) { return;
private void verifyDexFile(DexFile dexFile) { Assert.assertEquals(1, dexFile.getClasses().size()); ClassDef cls = Lists.newArrayList(dexFile.getClasses()).get(0); Assert.assertEquals("Lcls1;", cls.getType()); Assert.assertEquals(1, Lists.newArrayList(cls.getMethods()).size()); Method method = Iterators.getNext(cls.getMethods().iterator(), null); Assert.assertEquals("method1", method.getName()); Assert.assertEquals(1, Lists.newArrayList(method.getImplementation().getInstructions()).size()); Instruction instruction = Lists.newArrayList(method.getImplementation().getInstructions().iterator()).get(0); Assert.assertEquals(Opcode.INVOKE_CUSTOM, instruction.getOpcode()); Assert.assertTrue(((Instruction35c) instruction).getReference() instanceof CallSiteReference); } }
modifiers = classDef.getAccessFlags(); String descriptor = classDef.getSuperclass() != null? classDef.getSuperclass(): null; if (descriptor != null && descriptor.endsWith(";")) descriptor = descriptor.substring(0,descriptor.length()-1); //remove last ';' final List<String> intfList = classDef.getInterfaces(); int size = intfList == null ? 0 : intfList.size(); final Iterable<? extends Field> encInstFields = classDef.getInstanceFields(); List<IField> ifs = new LinkedList<>(); for (Field dexf : encInstFields) { final Iterable<? extends Field> encStatFields = classDef.getStaticFields(); List<IField> sfs = new LinkedList<>(); for (Field dexf : encStatFields) {
staticFields = ((DexBackedClassDef) classDef).getStaticFields(false); } else { staticFields = classDef.getStaticFields(); writer.write("# duplicate field ignored\n"); fieldWriter = new CommentingIndentingWriter(writer); System.err.println(String.format("Ignoring duplicate field: %s->%s", classDef.getType(), fieldString)); setInStaticConstructor = false; } else {
@Nullable private String getContainingClassForImplicitReference() { if (classDef.options.implicitReferences) { return classDef.classDef.getType(); } return null; }
private boolean canAccessClass(@Nonnull ClassDef accessorClassDef, @Nonnull ClassDef accesseeClassDef) { if (AccessFlags.PUBLIC.isSet(accesseeClassDef.getAccessFlags())) { return true; } // Classes can only be public or package private. Any private or protected inner classes are actually // package private. return getPackage(accesseeClassDef.getType()).equals(getPackage(accessorClassDef.getType())); }
HashSet<String> fieldsSetInStaticConstructor = new HashSet<String>(); for (Method method: classDef.getDirectMethods()) { if (method.getName().equals("<clinit>")) { MethodImplementation impl = method.getImplementation(); fieldRef.getDefiningClass().equals((classDef.getType()))) { fieldsSetInStaticConstructor.add(ReferenceUtil.getShortFieldDescriptor(fieldRef));
if (!TypeUtils.canAccessClass(thisClass.getType(), classPath.getClassDef(resolvedField.getDefiningClass()))) { while (!TypeUtils.canAccessClass(thisClass.getType(), fieldClass)) { String superclass = fieldClass.getSuperclass(); if (superclass == null) { throw new ExceptionWithContext("Couldn't find accessible class while resolving field %s", FieldReference newResolvedField = classPath.getClass(fieldClass.getType()).getFieldByOffset(fieldOffset); if (newResolvedField == null) { throw new ExceptionWithContext("Couldn't find accessible class while resolving field %s", ReferenceUtil.getShortFieldDescriptor(resolvedField)); resolvedField = new ImmutableFieldReference(fieldClass.getType(), newResolvedField.getName(), newResolvedField.getType());
private void visitInitStub(ClassDef classDef, MethodVisitor mv) { mv.visitCode(); mv.visitVarInsn(Opcodes.ALOAD, 0); if (classDef.getSuperclass() != null) { String superName = stripName(classDef.getSuperclass()); mv.visitMethodInsn(Opcodes.INVOKESPECIAL, superName, "<init>", "()V", false); } mv.visitInsn(Opcodes.RETURN); mv.visitMaxs(0, 0); mv.visitEnd(); }
/** * Returns true if this class is an interface. * * If this class is not defined, then this will throw an UnresolvedClassException * * @return True if this class is an interface */ public boolean isInterface() { ClassDef classDef = getClassDef(); return (classDef.getAccessFlags() & AccessFlags.INTERFACE.getValue()) != 0; }
private String[] buildInterfaces(ClassDef classDef) { List<String> interfaces = classDef.getInterfaces(); return interfaces.stream().map(this::stripName) .toArray(size -> new String[interfaces.size()]); }
@Override public Method read(String className, String member) throws Exception { org.jf.dexlib2.iface.ClassDef classDef = (org.jf.dexlib2.iface.ClassDef) reader.read(className,null); for(Method method:classDef.getMethods()){ if (method.getName().equals(member)){ return method; } } return null; } }
private String buildASMSignature(ClassDef classDef) { String signature = null; outer: for (Annotation annotation : classDef.getAnnotations()) { if (!annotation.getType().equals("Ldalvik/annotation/Signature;")) { continue; } StringBuilder sb = new StringBuilder(); for (AnnotationElement e : annotation.getElements()) { BuilderEncodedValues.BuilderArrayEncodedValue ev = (BuilderEncodedValues.BuilderArrayEncodedValue) e .getValue(); for (EncodedValue v : ev.getValue()) { BuilderEncodedValues.BuilderStringEncodedValue value = (BuilderEncodedValues.BuilderStringEncodedValue) v; sb.append(value.getValue()); } } signature = sb.toString(); break; } return signature; }
@Override @Nullable public String getSourceFile() { return classDef.getSourceFile(); }
@Nonnull private ArrayList<Field> getSortedInstanceFields(@Nonnull ClassDef classDef) { ArrayList<Field> fields = Lists.newArrayList(classDef.getInstanceFields()); Collections.sort(fields); return fields; }