@Override public IClass lookupClass(TypeName className) { IClass pc = parent.lookupClass(className); if (pc == null) { IClass c = syntheticClasses.get(className); return c; } else { return pc; } }
if (!cldr.getName().toString().equals("Primordial")) { for (IClass cls : Iterator2Iterable.make(cldr.iterateAllClasses())) { if (cls instanceof PhantomClass) continue; && !mtd.getDeclaringClass() .getClassLoader() .getName() .toString() .equals("Primordial")) {
protected AstTranslator(IClassLoader loader, Map<Object, CAstEntity> namedEntityResolver, ArrayOpHandler arrayOpHandler) { this.loader = loader; this.namedEntityResolver = namedEntityResolver; this.arrayOpHandler = arrayOpHandler!=null? arrayOpHandler: this; this.insts = loader.getInstructionFactory(); }
/** * Dump stats about the class hierarchy to stdout. */ public static void printStats(IClassHierarchy cha) throws IllegalArgumentException { if (cha == null) { throw new IllegalArgumentException("cha cannot be null"); } IClassLoader[] loaders = cha.getLoaders(); for (IClassLoader loader : loaders) { System.out.println("loader: " + loader); System.out.println(" classes: " + loader.getNumberOfClasses()); System.out.println(" methods: " + loader.getNumberOfMethods()); } } }
private void computeSuperclass() { superclassComputed = true; if (superName == null) { if (!getReference().equals(loader.getLanguage().getRootType())) { superClass = loader.lookupClass(loader.getLanguage().getRootType().getName()); } return; } superClass = loader.lookupClass(TypeName.findOrCreate(superName)); }
Collection<Annotation> getAnnotations(Field m) { List<Annotation> result = new ArrayList<>(); for(org.jf.dexlib2.iface.Annotation a : m.getAnnotations()) { result.add(DexUtil.getAnnotation(a, getClassLoader().getReference())); } return result; }
final Iterator<IClass> appIt = appLoader.iterateAllClasses(); for (final IMethod ifMethod : ifMethods) { final IMethod method = appClass.getMethod(ifMethod.getSelector()); if (method != null && method.getDeclaringClass().getClassLoader().getReference().equals(ClassLoaderReference.Application)) {
@Override public void visitInvoke(IInvokeInstruction instruction) { IClassLoader loader = getDeclaringClass().getClassLoader(); MethodReference m = MethodReference.findOrCreate(loader.getLanguage(), loader.getReference(), instruction.getClassType(), instruction.getMethodName(), instruction.getMethodSignature()); int programCounter = 0; programCounter = getProgramCounter(); CallSiteReference site = null; site = CallSiteReference.make(programCounter, m, instruction.getInvocationCode()); callSites.add(site); }
/** * @return the unique name that identifies the programming language * from which this class loader loads code. */ @Override public Language getLanguage() { return parent.getLanguage(); }
private static ClassLoaderReference findLoader(String loaderName, IClassHierarchy cha) { Atom loaderAtom = Atom.findOrCreateUnicodeAtom(loaderName); IClassLoader[] loaders = cha.getLoaders(); for (IClassLoader loader : loaders) { if (loader.getName() == loaderAtom) { return loader.getReference(); } } Assertions.UNREACHABLE(); return null; }
@Override public SSANewInstruction addAllocation(TypeReference T) { if (cha.isSubclassOf(cha.lookupClass(T), cha.lookupClass(declaringClass.getClassLoader().getLanguage().getRootType()))) { int instance = nextLocal++; NewSiteReference ref = NewSiteReference.make(statements.size(), T); SSANewInstruction result = getDeclaringClass().getClassLoader().getInstructionFactory().NewInstruction(statements.size(), instance, ref); statements.add(result); return result; } else { return super.addAllocation(T); } }
@Override public Iterator<IClass> makeInner(ClassLoaderReference o) { IClassLoader ldr = getLoader(o); return ldr.iterateAllClasses(); } };
@Override public boolean check(CGNode n) { return n.getMethod().getDeclaringClass().getClassLoader().getName().equals(AnalysisScope.APPLICATION); }
/** * Add all classes in a class loader to the hierarchy. */ private void addAllClasses(IClassLoader loader, IProgressMonitor progressMonitor) throws CancelCHAConstructionException { if (DEBUG) { System.err.println(("Add all classes from loader " + loader)); } Collection<IClass> toRemove = HashSetFactory.make(); for (IClass klass : Iterator2Iterable.make(loader.iterateAllClasses())) { if (progressMonitor != null) { if (progressMonitor.isCanceled()) { throw new CancelCHAConstructionException(); } } boolean added = addClass(klass); if (!added) { toRemove.add(klass); } } loader.removeAll(toRemove); }
@Override public int getNumberOfClasses() { int total = 0; for (ClassLoaderReference loaderReference : analysisScope.getLoaders()) { total += getLoader(loaderReference).getNumberOfClasses(); } return total; }
@Override public IClassLoader getLoader(ClassLoaderReference loaderRef) { for (IClassLoader loader : loaders) { if (loader.getReference().equals(loaderRef)) { return loader; } } Assertions.UNREACHABLE(); return null; }
private void computeSuperclass() { superclassComputed = true; if (superName == null) { if (!getReference().equals(loader.getLanguage().getRootType())) { superClass = loader.lookupClass(loader.getLanguage().getRootType().getName()); } return; } superClass = loader.lookupClass(TypeName.findOrCreate(superName)); }
final Iterator<IClass> appIt = appLoader.iterateAllClasses(); for (final IMethod ifMethod : ifMethods) { final IMethod method = appClass.getMethod(ifMethod.getSelector()); if (method != null && method.getDeclaringClass().getClassLoader().getReference().equals(ClassLoaderReference.Application)) {
@Override protected void leaveTypeLiteralExpr(CAstNode n, WalkContext c, CAstVisitor<WalkContext> visitor) { WalkContext wc = c; assert n.getChild(0).getKind() == CAstNode.CONSTANT; String typeNameStr = (String) n.getChild(0).getValue(); TypeName typeName = TypeName.string2TypeName(typeNameStr); TypeReference typeRef = TypeReference.findOrCreate(loader.getReference(), typeName); int result = wc.currentScope().allocateTempValue(); c.setValue(n, result); wc.cfg().addInstruction(insts.LoadMetadataInstruction(wc.cfg().currentInstruction, result, loader.getLanguage().getConstantType(typeRef), typeRef)); }
/** * @return the unique name that identifies the programming language * from which this class loader loads code. */ @Override public Language getLanguage() { return parent.getLanguage(); }