import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
public static IMethod getIMethod(IClassHierarchy cha, String signature) {  // TODO: throw exceptions
	String clazzName = Utils.getFullClassName(signature);
	String selector = signature.substring(clazzName.length()+1); 

	try {
		IClass clazz = WalaUtils.lookupClass(cha, clazzName);
		for (IMethod m: clazz.getAllMethods()) { // DeclaredMethods()) -> only impl./overriden methods
			if (m.getSelector().toString().equals(selector)) {
				return m;
			}
		}
	} catch (ClassNotFoundException e) {
		logger.debug("Classname " + clazzName + " could not be looked up!");
	}
	return null;  // TODO: throw exception
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
private IClass getLayoutClass(IClassHierarchy cha, String clazzName) {
	// This is due to the fault-tolerant xml parser
	if (clazzName.equals("view")) clazzName = "View";

	IClass iclazz = null;
	if (iclazz == null)
		iclazz = cha.lookupClass(TypeReference.findOrCreate(ClassLoaderReference.Application, Utils.convertToBrokenDexBytecodeNotation(clazzName)));
	if (iclazz == null && !packageName.isEmpty())
		iclazz = cha.lookupClass(TypeReference.findOrCreate(ClassLoaderReference.Application, Utils.convertToBrokenDexBytecodeNotation(packageName + "." + clazzName)));
	if (iclazz == null)
		iclazz = cha.lookupClass(TypeReference.findOrCreate(ClassLoaderReference.Application, Utils.convertToBrokenDexBytecodeNotation("android.widget." + clazzName)));
	if (iclazz == null)	
		iclazz = cha.lookupClass(TypeReference.findOrCreate(ClassLoaderReference.Application, Utils.convertToBrokenDexBytecodeNotation("android.webkit." + clazzName)));
	if (iclazz == null)
		iclazz = cha.lookupClass(TypeReference.findOrCreate(ClassLoaderReference.Application, Utils.convertToBrokenDexBytecodeNotation("android.view." + clazzName)));
	
	// PreferenceScreen, PreferenceCategory, (i)shape, item, selector, scale, corners, solid .. tags are no classes and thus there will be no corresponding layout class
	if (iclazz == null)	
		logger.trace(Utils.INDENT + "Could not find layout class " + clazzName);

	return iclazz;
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
/**
 * This main program shows one example use of thread escape analysis: producing a set of fields to be monitored for a
 * dynamic race detector. The idea is that any field might have a race with two exceptions: final fields do not have
 * races since there are no writes to them, and volatile fields have atomic read and write semantics provided by the
 * VM. Hence, this piece of code produces a list of all other fields.
 * @throws CancelException
 * @throws IllegalArgumentException
 */
public static void main(String[] args) throws IOException, ClassHierarchyException, IllegalArgumentException, CancelException {
  String mainClassName = args[0];

  Set<JarFile> jars = HashSetFactory.make();
  for (int i = 1; i < args.length; i++) {
    jars.add(new JarFile(args[i]));
  }

  Set<IClass> escapingTypes = (new SimpleThreadEscapeAnalysis(jars, mainClassName)).gatherThreadEscapingClasses();

  for (Iterator<IClass> types = escapingTypes.iterator(); types.hasNext();) {
    IClass cls = types.next();
    if (!cls.isArrayClass()) {
      for (Iterator<IField> fs = cls.getAllFields().iterator(); fs.hasNext();) {
        IField f = fs.next();
        if (!f.isVolatile() && !f.isFinal()) {
          System.err.println(f.getReference());
        }
      }
    }
  }
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
/**
 * @return True iff the given call site indicates that the enclosing call graph node is
 * considered an "initial" node.
 */
private static boolean isInitialNodeByCallSite(CGNode node, CallSiteReference callSite)
{
    IClassHierarchy cha = node.getClassHierarchy();
    MethodReference calleeMethod = callSite.getDeclaredTarget();
    IClass calleeClass = cha.lookupClass(calleeMethod.getDeclaringClass());

    if (calleeClass == null || isCapsuleInterface(calleeClass) == false) {
        return false;
    }
    if (calleeMethod.getNumberOfParameters() == 0) {
        return false;
    }
    
    return true;
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
/**
 * Returns a set of all of the entrypoints on the given capsule core.
 * 
 * @param core A well-formed capsule core class, annotated with `@Capsule`.
 */
public static Set<Entrypoint> makeAll(IClass core)
{
    assert isCapsuleCore(core);

    Set<Entrypoint> entrypoints = HashSetFactory.make();
    final Consumer<IMethod> addEntrypoint = (m -> entrypoints.add(new CapsuleCoreEntrypoint(m)));

    // The way in which `entrypoints` is populated depends on whether the capsule core 
    // defines an active or passive capsule. If active, then the only entrypoint is `run()`.
    // If passive, then every procedure is an entrypoint.
    IMethod runDecl = getRunDecl(core);
    if (runDecl != null) {
        addEntrypoint.accept(runDecl);
    } else {
        getProceduresList(core).forEach(addEntrypoint);
    }
    return entrypoints;
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
private void processClass(List<TypeLabel> filteredList,
		TargetApplication targetApplication,
		Map<String, AnalysisResult> analysisResult, IClass clazz) {

	for (IMethod m : clazz.getDeclaredMethods()) {
		try {
			AnalyzedMethod method = targetApplication.findIRMethodForMethod(m);

			if (method != null) {
				MethodAnalyzer analyzer = new MethodAnalyzer(method, filteredList);

				AnalysisResult candidates = analyzer.analyze();

				if (!candidates.isEmpty()) {
					analysisResult.put(m.getSignature(), candidates);
				}
			} else {
				LOG.error("method is skipped");
			}
		} catch (Exception e) {
			FileUtil.handleError(e, m.getSignature());
		}
	}
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
/**
 * main method to print out all ir for the test classes
 * @param args no args defined
 * @throws IOException
 * @throws WalaException
 */
public static void main(String[] args) throws IOException, WalaException {
	String pathname = TARGET_IRS;

	if (args.length > 0) {
		pathname = args[0];
	}

	TargetApplication targetApplication = TestUtilities.loadTestJar();

	for (IClass clazz : targetApplication.getApplicationClasses()) {
		for (IMethod m : clazz.getDeclaredMethods()) {
			printToPDF(pathname, targetApplication.getClassHierachy(), targetApplication.findIRForMethod(m));
		}
	}
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
protected static IClass lookUpClass(String name) {
	checkNotNull(name, "name of class must not be null");

	if (testClassMap == null) {
		initTestClasses();
	}

	IClass cl = testClassMap.get(name);

	if (cl != null) {
		return cl;
	} else {
		throw new IllegalArgumentException(
				String.format("no class with name '%s' could be found in "
					+ "the test class hierachie",
					name));
	}

}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
private AnalyzedMethod createMethodFor(String className, String methodName, String jarName) {
	TargetApplication application = TestUtilities.loadTestJar("target/" + jarName);
	for (IClass cl : application.getClassHierachy()) {
		if (cl.getName().toString().endsWith(className)) {
			LOG.info("found class {}", className);
			for (IMethod m : cl.getAllMethods()) {
				if (m.getName().toString().equals(methodName) || m.getSignature().equals(methodName)) {
					try {
						PrintTestIRs.printToPDF("target", application.getClassHierachy(), application.findIRForMethod(m));
					} catch (WalaException | IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}

					LOG.info("found method {}; {}", m.getSignature());
					return application.findIRMethodForMethod(m);

				}
			}
		}
	}

	throw new IllegalStateException(String.format("no method found %s %s", className, methodName));
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
/**
 * Looks up a method by name in a class object. If the method is overloaded,
 * the first one found is returned.
 * @param clazz  IClass object
 * @param methodName name of the method to be looked up
 * @return IMethod if method is declared in clazz, null otherwise
 */
public static IMethod getMethodByName(IClass clazz, String methodName) {
	for (IMethod m: clazz.getAllMethods()) { // DeclaredMethods()) -> only impl./overriden methods
		if (m.getSelector().toString().startsWith(methodName)) {
			return m;
		}
	}
	return null;
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
/**
 * Hierarchical lookup of an {@link IMethod} via {@link IClass} and {@link CallSiteReference}.
 * @param clazz   the {@link IClass} to start with
 * @param csr  the {@link CallSiteReference}
 * @return  a {@link IMethod} object of the resolved method or null
	 */
public static IMethod resolveMethod(IClass clazz, CallSiteReference csr) {
	IMethod targetMethod = null;

	while (targetMethod == null && !WalaUtils.isObjectClass(clazz)) {
		targetMethod = clazz.getMethod(csr.getDeclaredTarget().getSelector());
		if (targetMethod != null)
			break;

		clazz = clazz.getSuperclass();
	}
	return targetMethod;
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
/**
 * Collects all implemented interfaces for a given class
 * @param clazz  the IClass object to analyze
 * @return a set of IClass objects representing the interfaces
 */
public static Set<IClass> collectAllInterfaces(IClass clazz) {
	// do not check array classes
	if (clazz.isArrayClass()) return new HashSet<IClass>();
	
	Set<IClass> interfaces = new HashSet<IClass>(clazz.getDirectInterfaces());
	for (IClass c : clazz.getDirectInterfaces())
		interfaces.addAll(collectAllInterfaces(c));

	return interfaces;
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
/**
 * Looks up an IClass for a given class name
 * @param cha  a {@link IClassHierarchy}
 * @param clazzName  in java notation, e.g. "de.infsec.MyActivity"
 * @return a {@link IClass} object
 * @throws ClassNotFoundException
 */
public static IClass lookupClass(IClassHierarchy cha, String clazzName) throws ClassNotFoundException {
	if (clazzName == null)
		throw new ClassNotFoundException(Utils.INDENT + "class name is NULL");
	
	String convertedClass = Utils.convertToBrokenDexBytecodeNotation(clazzName);
	IClass iclazz = cha.lookupClass(TypeReference.findOrCreate(ClassLoaderReference.Application, convertedClass));
	
	if (iclazz == null)
		throw new ClassNotFoundException(Utils.INDENT + "[lookupClass] Could'nt lookup IClass for " + clazzName);
	
	return iclazz;
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
public static boolean isAppClass(IClass clazz) {
	// Normalization:
	// filter empty dummy classes
	// possibly related too: http://bugs.java.com/bugdatabase/view_bug.do?bug_id=4295934
	boolean isEmptyInnerClass = WalaUtils.isInnerClass(clazz)
								&& isAnonymousInnerClass(clazz)
								&& (clazz.getDeclaredMethods().isEmpty() || 
								   (clazz.getDeclaredMethods().size() == 1 && clazz.getDeclaredMethods().iterator().next().isClinit())
								&& clazz.getDeclaredInstanceFields().isEmpty()
								&& clazz.getDeclaredStaticFields().isEmpty()
								&& clazz.getDirectInterfaces().isEmpty());

	return clazz.getClassHierarchy().getScope().isApplicationLoader(clazz.getClassLoader()) && !isAndroidResourceClass(clazz) && !isEmptyInnerClass && !clazz.isSynthetic();
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
/**
 * Retrieves all superclasses for a given class including itself
 * @param clazz  the input IClass object
 * @return  a list of IClass superclass objects including the input class
 */
public static List<IClass> getSuperClassesIncluding(IClass clazz) {
	LinkedList<IClass> superclasses = new LinkedList<IClass>(getSuperClasses(clazz));
	superclasses.addFirst(clazz);
	
	return superclasses;
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
/**
 * Retrieves all superclasses for a given class
 * @param clazz  the input IClass object
 * @return  a list of IClass superclass objects or an empty list if there is no superclass
 */
public static List<IClass> getSuperClasses(IClass clazz) {
	ArrayList<IClass> superclasses = new ArrayList<IClass>();

	while (clazz.getSuperclass() != null) {  
		clazz = clazz.getSuperclass();
		superclasses.add(clazz);
	}
	
	return superclasses;
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
public static boolean isInnerClassOf(IClass clazz, IClass testClazz) {
	// TODO: innerclass check would be easier if the dex bytecode annotations would have been parsed!
	//       here we have to fallback to the potentially non-reliable name check
	String clazzName = getClassName(clazz);
	String testClazzName = getClassName(testClazz);
	
	return testClazzName.contains("$") && testClazzName.startsWith(clazzName);
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
@Override
    	public NodeVisitor child(String ns, String name) {
if (name == null || name.isEmpty()) {
 			logger.trace(Utils.INDENT + "Encountered a null node name or empty node name "
 					+ "in file " + layoutFile + ", skipping node...");
 			return null;
 		}
			
 		String tname = name.trim();
 		if (tname.equals("include"))       /// TODO NOT SURE IF THIS IS CORRECT, include can occur in the middle of the file, anything afterwards seems not to be parsed anymore
 		   return new IncludeParser(layoutFile);

 		// For layout defined fragments we need the class name that is either specified via the name- or class-tag
 		if (tname.equals("fragment")) 
 			return new FragmentParser(cha, layoutFile, clazz);

 		// The "merge" tag merges the next hierarchy level into the current
 		// one for flattening hierarchies.
 		if (tname.equals("merge"))
 		    return new LayoutParser(cha, layoutFile, clazz);
 		
final IClass childClass = getLayoutClass(cha, tname);
if (childClass != null && 
   (WalaUtils.classifyClazz(childClass) == AndroidClassType.LayoutContainer || WalaUtils.classifyClazz(childClass) == AndroidClassType.View))
    			return new LayoutParser(cha, layoutFile, childClass);
else
	return super.child(ns, name);
    	}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
public static PackageTree make(IClassHierarchy cha, boolean appClassesOnly, Set<String> filteredPackages) {
	PackageTree tree = new PackageTree();
	for (Iterator<IClass> it = cha.iterator(); it.hasNext(); ) {
		IClass clazz = it.next();
		if (!appClassesOnly || (appClassesOnly && WalaUtils.isAppClass(clazz))) {
			if (filteredPackages == null || !filteredPackages.contains(PackageUtils.getPackageName(clazz)))
				tree.update(clazz);
		}
	}
	return tree;
	
}
 

import com.ibm.wala.classLoader.IClass; //导入依赖的package包/类
public void updateTreeClazzCount(IClassHierarchy cha) {
	Set<String> packages = this.getAllPackages();
	
	for (Iterator<IClass> it = cha.iterator(); it.hasNext(); ) {
		IClass clazz = it.next();
		if (WalaUtils.isAppClass(clazz)) {
			if (packages.contains(PackageUtils.getPackageName(clazz))) {
				updateClazzCount(clazz);
			}
		}
	}
	
}