> methodCalls = new HashSet<>();
- private final JarMetadata jarMetadata;
+ private boolean isTestClass;
- public ClassVisitor(JavaClass jc, JarMetadata jarMetadata) {
+ public ClassVisitor(JavaClass jc, JarMetadata jarMetadata, boolean isTestClass) {
clazz = jc;
constants = new ConstantPoolGen(clazz.getConstantPool());
this.jarMetadata = jarMetadata;
+ this.isTestClass = isTestClass;
classReferenceFormat = "C:" + clazz.getClassName() + " %s";
}
@@ -72,18 +72,16 @@ public void visitJavaClass(JavaClass jc) {
public void visitConstantPool(ConstantPool constantPool) {
for (int i = 0; i < constantPool.getLength(); i++) {
Constant constant = constantPool.getConstant(i);
- if (constant == null)
- continue;
+ if (constant == null) continue;
if (constant.getTag() == 7) {
- String referencedClass =
- constantPool.constantToString(constant);
+ String referencedClass = constantPool.constantToString(constant);
}
}
}
public void visitMethod(Method method) {
MethodGen mg = new MethodGen(method, clazz.getClassName(), constants);
- MethodVisitor visitor = new MethodVisitor(mg, clazz, jarMetadata);
+ MethodVisitor visitor = new MethodVisitor(mg, clazz, jarMetadata, isTestClass);
methodCalls.addAll(visitor.start());
}
diff --git a/src/main/java/gr/gousiosg/javacg/stat/DynamicCallManager.java b/src/main/java/gr/gousiosg/javacg/stat/DynamicCallManager.java
index de8ce3b9..1f0fde1c 100644
--- a/src/main/java/gr/gousiosg/javacg/stat/DynamicCallManager.java
+++ b/src/main/java/gr/gousiosg/javacg/stat/DynamicCallManager.java
@@ -23,43 +23,37 @@
import java.util.regex.Pattern;
/**
- * {@link DynamicCallManager} provides facilities to retrieve information about
- * dynamic calls statically.
- *
- * Most of the time, call relationships are explicit, which allows to properly
- * build the call graph statically. But in the case of dynamic linking, i.e.
- * invokedynamic instructions, this relationship might be unknown
- * until the code is actually executed. Indeed, bootstrap methods are used to
- * dynamically link the code at first call. One can read details about the
- * invokedynamic
- * instruction to know more about this mechanism.
- *
- * Nested lambdas are particularly subject to such absence of concrete caller,
- * which lead us to produce method names like lambda$null$0, which
- * breaks the call graph. This information can however be retrieved statically
- * through the code of the bootstrap method called.
- *
- * In {@link #retrieveCalls(Method, JavaClass)}, we retrieve the (called,
- * caller) relationships by analyzing the code of the caller {@link Method}.
- * This information is then used in {@link #linkCalls(Method)} to rename the
- * called {@link Method} properly.
+ * {@link DynamicCallManager} provides facilities to retrieve information about dynamic calls
+ * statically.
+ *
+ *
Most of the time, call relationships are explicit, which allows to properly build the call
+ * graph statically. But in the case of dynamic linking, i.e. invokedynamic
+ * instructions, this relationship might be unknown until the code is actually executed. Indeed,
+ * bootstrap methods are used to dynamically link the code at first call. One can read details about
+ * the
+ * invokedynamic instruction to know more about this mechanism.
+ *
+ *
Nested lambdas are particularly subject to such absence of concrete caller, which lead us to
+ * produce method names like lambda$null$0, which breaks the call graph. This
+ * information can however be retrieved statically through the code of the bootstrap method called.
+ *
+ *
In {@link #retrieveCalls(Method, JavaClass)}, we retrieve the (called, caller) relationships
+ * by analyzing the code of the caller {@link Method}. This information is then used in {@link
+ * #linkCalls(Method)} to rename the called {@link Method} properly.
*
* @author Matthieu Vergne
*/
public class DynamicCallManager {
- private static Logger LOGGER = LoggerFactory.getLogger(DynamicCallManager.class);
-
- private static final Pattern BOOTSTRAP_CALL_PATTERN = Pattern
- .compile("invokedynamic\t(\\d+):\\S+ \\S+ \\(\\d+\\)");
+ private static final Pattern BOOTSTRAP_CALL_PATTERN =
+ Pattern.compile("invokedynamic\t(\\d+):\\S+ \\S+ \\(\\d+\\)");
private static final int CALL_HANDLE_INDEX_ARGUMENT = 1;
-
+ private static Logger LOGGER = LoggerFactory.getLogger(DynamicCallManager.class);
private final Map dynamicCallers = new HashMap<>();
/**
- * Retrieve dynamic call relationships based on the code of the provided
- * {@link Method}.
+ * Retrieve dynamic call relationships based on the code of the provided {@link Method}.
*
* @param method {@link Method} to analyze the code
* @param jc {@link JavaClass} info, which contains the bootstrap methods
@@ -92,7 +86,8 @@ public void retrieveCalls(Method method, JavaClass jc) {
private String getMethodNameFromHandleIndex(ConstantPool cp, int callIndex) {
ConstantMethodHandle handle = (ConstantMethodHandle) cp.getConstant(callIndex);
ConstantCP ref = (ConstantCP) cp.getConstant(handle.getReferenceIndex());
- ConstantNameAndType nameAndType = (ConstantNameAndType) cp.getConstant(ref.getNameAndTypeIndex());
+ ConstantNameAndType nameAndType =
+ (ConstantNameAndType) cp.getConstant(ref.getNameAndTypeIndex());
return nameAndType.getName(cp);
}
diff --git a/src/main/java/gr/gousiosg/javacg/stat/GraphUtils.java b/src/main/java/gr/gousiosg/javacg/stat/GraphUtils.java
deleted file mode 100644
index 83cd5a38..00000000
--- a/src/main/java/gr/gousiosg/javacg/stat/GraphUtils.java
+++ /dev/null
@@ -1,400 +0,0 @@
-package gr.gousiosg.javacg.stat;
-
-import gr.gousiosg.javacg.dyn.Pair;
-import gr.gousiosg.javacg.stat.support.IgnoredConstants;
-import gr.gousiosg.javacg.stat.support.JarMetadata;
-import gr.gousiosg.javacg.stat.support.coverage.ColoredNode;
-import org.apache.bcel.classfile.ClassParser;
-import org.jgrapht.Graph;
-import org.jgrapht.graph.DefaultDirectedGraph;
-import org.jgrapht.graph.DefaultEdge;
-import org.jgrapht.nio.Attribute;
-import org.jgrapht.nio.DefaultAttribute;
-import org.jgrapht.nio.dot.DOTExporter;
-import org.reflections.Reflections;
-import org.reflections.scanners.SubTypesScanner;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.*;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.*;
-import java.util.function.Function;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
-
-/**
- * Provides graph utilities such as:
- * - Building a graph ({@link GraphUtils#buildGraph(Map)})
- * - Finding the reachability in a graph ({@link GraphUtils#reachability(Graph, String, Optional)})
- * - Finding the ancestry in a graph ({@link GraphUtils#ancestry(Graph, String, int)})
- */
-public class GraphUtils {
-
- private static final Logger LOGGER = LoggerFactory.getLogger(GraphUtils.class);
-
- private static final String LABEL = "label";
- private static final String STYLE = "style";
- private static final String FILLCOLOR = "fillcolor";
- private static final String FILLED = "filled";
- private static final String NODE_DELIMITER = "\"";
-
- public static Graph reachability(Graph graph, String entrypoint, Optional maybeMaximumDepth) {
-
- if (!graph.containsVertex(entrypoint)) {
- LOGGER.error("---> " + entrypoint + "<---");
- LOGGER.error("The graph doesn't contain the vertex specified as the entry point!");
- throw new InputMismatchException("graph doesn't contain vertex " + entrypoint);
- }
-
- if (maybeMaximumDepth.isPresent() && (maybeMaximumDepth.get() < 0)) {
- LOGGER.error("Depth " + maybeMaximumDepth.get() + " must be greater than 0!");
- System.exit(1);
- }
-
- LOGGER.info("Starting reachability at entry point: " + entrypoint);
- maybeMaximumDepth.ifPresent(d -> LOGGER.info("Traversing to depth " + d));
-
- Graph subgraph = new DefaultDirectedGraph<>(DefaultEdge.class);
- int currentDepth = 0;
-
- Deque reachable = new ArrayDeque<>();
- reachable.push(entrypoint);
-
- Map subgraphNodes = new HashMap<>();
- Set seenBefore = new HashSet<>();
- Set nextLevel = new HashSet<>();
-
- while (!reachable.isEmpty()) {
-
- /* Stop once we've surpassed maximum depth */
- if (maybeMaximumDepth.isPresent() && (maybeMaximumDepth.get() < currentDepth)) {
- break;
- }
-
- while (!reachable.isEmpty()) {
- /* Visit reachable node */
- String source = reachable.pop();
- ColoredNode sourceNode = subgraphNodes.containsKey(source) ? subgraphNodes.get(source) : new ColoredNode(source);
-
- /* Keep track of who we've visited */
- seenBefore.add(source);
- if (!subgraphNodes.containsKey(source)) {
- subgraph.addVertex(sourceNode);
- subgraphNodes.put(source, sourceNode);
- }
-
- /* Check if we can add deeper edges or not */
- if (maybeMaximumDepth.isPresent() && (maybeMaximumDepth.get() == currentDepth)) {
- break;
- }
-
- graph.edgesOf(source).forEach(edge -> {
- String target = graph.getEdgeTarget(edge);
- ColoredNode targetNode = subgraphNodes.containsKey(target) ? subgraphNodes.get(target) : new ColoredNode(target);
-
- if (!subgraphNodes.containsKey(target)) {
- subgraphNodes.put(target, targetNode);
- subgraph.addVertex(targetNode);
- }
-
- if (graph.containsEdge(source, target) && !subgraph.containsEdge(sourceNode, targetNode)) {
- subgraph.addEdge(sourceNode, targetNode);
- }
-
- /* Have we visited this vertex before? */
- if (!seenBefore.contains(target)) {
- nextLevel.add(target);
- seenBefore.add(target);
- }
-
- });
- }
-
- currentDepth++;
- reachable.addAll(nextLevel);
- nextLevel.clear();
- }
-
- subgraphNodes.get(entrypoint).markEntryPoint();
- return subgraph;
- }
-
- public static Graph ancestry(Graph graph, String entrypoint, int ancestryDepth) {
-
- if (!graph.containsVertex(entrypoint)) {
- LOGGER.error("---> " + entrypoint + "<---");
- LOGGER.error("The graph doesn't contain the vertex specified as the entry point!");
- throw new InputMismatchException("graph doesn't contain vertex " + entrypoint);
- }
-
- LOGGER.info("Starting ancestry at entry point: " + entrypoint);
- LOGGER.info("Traversing to depth " + ancestryDepth);
-
- /* Book-keeping */
- Graph ancestry = new DefaultDirectedGraph<>(DefaultEdge.class);
- Map nodeMap = new HashMap<>();
- Deque parentsToInspect = new ArrayDeque<>();
- Set seenBefore = new HashSet<>();
- Set nextLevel = new HashSet<>();
-
- /* Add root node to ancestry graph */
- ColoredNode root = new ColoredNode(entrypoint);
- ancestry.addVertex(root);
- nodeMap.put(entrypoint, root);
- parentsToInspect.push(entrypoint);
-
- int currentDepth = 0;
- while (!parentsToInspect.isEmpty()) {
-
- if (ancestryDepth < currentDepth) {
- break;
- }
-
- /* Loop over all nodes that we haven't yet seen yet and are reachable at depth "currentDepth" */
- while (!parentsToInspect.isEmpty()) {
-
- /* Fetch next node */
- String child = parentsToInspect.pop();
- ColoredNode childNode = nodeMap.containsKey(child) ? nodeMap.get(child) : new ColoredNode(child);
-
- /* Keep track of who we've seen before */
- seenBefore.add(child);
- if (!nodeMap.containsKey(child)) {
- ancestry.addVertex(childNode);
- nodeMap.put(child, childNode);
- }
-
- graph.incomingEdgesOf(child).forEach(incomingEdge -> {
- String parent = graph.getEdgeSource(incomingEdge);
- ColoredNode parentNode = nodeMap.containsKey(parent) ? nodeMap.get(parent) : new ColoredNode(parent);
-
- if (!nodeMap.containsKey(parent)) {
- nodeMap.put(parent, parentNode);
- ancestry.addVertex(parentNode);
- }
-
- ancestry.addEdge(parentNode, childNode);
-
- /* Have we visited this vertex before? */
- if (!seenBefore.contains(parent)) {
- nextLevel.add(parent);
- seenBefore.add(parent);
- }
- });
- }
-
- currentDepth++;
- parentsToInspect.addAll(nextLevel);
- nextLevel.clear();
- }
-
- nodeMap.get(entrypoint).markEntryPoint();
- return ancestry;
- }
-
- public static void writeGraph(Graph graph, DOTExporter exporter, Optional maybeOutputName) {
- LOGGER.info("Attempting to store callgraph...");
-
- if (maybeOutputName.isEmpty()) {
- LOGGER.error("No output name specified!");
- return;
- }
-
- /* Write to .dot file in output directory */
- String path = JCallGraph.OUTPUT_DIRECTORY + maybeOutputName.get();
- try {
- Writer writer = new FileWriter(path);
- exporter.exportGraph(graph, writer);
- LOGGER.info("Graph written to " + path + "!");
- } catch (IOException e) {
- LOGGER.error("Unable to write callgraph to " + path);
- }
- }
-
- public static Graph staticCallgraph(List> jars) throws InputMismatchException {
- LOGGER.info("Beginning callgraph analysis...");
-
- /* Load JAR URLs */
- List urls = new ArrayList<>();
- try {
- for (Pair pair : jars) {
- URL url = new URL("jar:file:" + pair.first + "!/");
- urls.add(url);
- }
- } catch (MalformedURLException e) {
- LOGGER.error("Error loading URLs: " + e.getMessage());
- throw new InputMismatchException("Couldn't load provided JARs");
- }
-
- if (urls.isEmpty()) {
- LOGGER.error("No URLs to scan!");
- throw new InputMismatchException("There are no URLs to scan!");
- }
-
- /* Setup infrastructure for analysis */
- URLClassLoader cl = URLClassLoader.newInstance(urls.toArray(new URL[0]), ClassLoader.getSystemClassLoader());
- Reflections reflections = new Reflections(cl, new SubTypesScanner(false));
- JarMetadata jarMetadata = new JarMetadata(cl, reflections);
-
- /* Store method calls (caller -> receiver) */
- Map> calls = new HashMap<>();
-
- for (Pair pair : jars) {
- String jarPath = pair.first;
- File file = pair.second;
-
- try (JarFile jarFile = new JarFile(file)) {
- LOGGER.info("Analyzing: " + jarFile.getName());
- Stream entries = enumerationAsStream(jarFile.entries());
-
- Function getClassVisitor =
- (ClassParser cp) -> {
- try {
- return new ClassVisitor(cp.parse(), jarMetadata);
- } catch (IOException e) {
- throw new UncheckedIOException(e);
- }
- };
-
- /* Analyze each jar entry to find callgraph */
- entries.flatMap(e -> {
- if (e.isDirectory() || !e.getName().endsWith(".class"))
- return Stream.of();
-
- /* Ignore specified JARs */
- if (shouldIgnoreEntry(e.getName().replace("/", "."))) {
- return Stream.of();
- } else {
- LOGGER.info("Inspecting " + e.getName());
- }
-
- ClassParser cp = new ClassParser(jarPath, e.getName());
- return getClassVisitor.apply(cp).start().methodCalls().stream();
- }).forEach(p -> {
- /* Create edges between nodes */
- calls.putIfAbsent((p.first), new HashSet<>());
- calls.get(p.first).add(p.second);
- });
-
- } catch (IOException e) {
- LOGGER.error("Error when analyzing JAR \"" + jarPath + "\": + e.getMessage()");
- e.printStackTrace();
- }
- }
-
- /* Convert calls into a graph */
- Graph graph = buildGraph(calls);
-
- /* Prune bridge methods from graph */
- jarMetadata.getBridgeMethods().forEach(bridgeMethod -> {
-
- /* Fetch the bridge method and make sure it has exactly one outgoing edge */
- String bridgeNode = formatNode(bridgeMethod);
- Optional maybeEdge = graph.outgoingEdgesOf(bridgeNode).stream().findFirst();
-
- if (graph.outDegreeOf(bridgeNode) != 1 || maybeEdge.isEmpty()) {
-
- graph.outgoingEdgesOf(bridgeNode).stream().forEach(e -> {
- LOGGER.error("\t" + graph.getEdgeSource(e) + " -> " + graph.getEdgeTarget(e));
- });
- LOGGER.error("Found a bridge method that doesn't have exactly 1 outgoing edge: " + bridgeMethod + " : " + graph.outDegreeOf(bridgeNode));
- System.exit(1);
- }
-
- /* Fetch the bridge method's target */
- String bridgeTarget = graph.getEdgeTarget(maybeEdge.get());
-
- /* Redirect all edges from the bridge method to its target */
- graph.incomingEdgesOf(bridgeNode).forEach(edge -> {
- String sourceNode = graph.getEdgeSource(edge);
- graph.addEdge(sourceNode, bridgeTarget);
- });
-
- /* Remove the bridge method from the graph */
- graph.removeVertex(bridgeNode);
- });
-
- return graph;
- }
-
- private static Graph buildGraph(Map> methodCalls) throws InputMismatchException {
- if (methodCalls.keySet().isEmpty()) {
- throw new InputMismatchException("There is no call graph to look at!");
- }
-
- /* initialize the graph */
- Graph graph = new DefaultDirectedGraph<>(DefaultEdge.class);
-
- /* fill the graph with vertices and edges */
- methodCalls.keySet().forEach(source -> {
- String sourceNode = formatNode(source);
- putIfAbsent(graph, sourceNode);
-
- methodCalls.get(source).forEach(destination -> {
- String destinationNode = formatNode(destination);
- putIfAbsent(graph, destinationNode);
- graph.addEdge(sourceNode, destinationNode);
- });
- });
-
- return graph;
- }
-
- private static void putIfAbsent(Graph graph, String vertex) {
- if (!graph.containsVertex(vertex)) {
- graph.addVertex(vertex);
- }
- }
-
- private static boolean shouldIgnoreEntry(String entry) {
- return IgnoredConstants.IGNORED_CALLING_PACKAGES.stream()
- .anyMatch(entry::startsWith);
- }
-
- public static String formatNode(String node) {
- return NODE_DELIMITER + node + NODE_DELIMITER;
- }
-
- public static Stream enumerationAsStream(Enumeration e) {
- return StreamSupport.stream(
- Spliterators.spliteratorUnknownSize(
- new Iterator() {
- public T next() {
- return e.nextElement();
- }
-
- public boolean hasNext() {
- return e.hasMoreElements();
- }
- },
- Spliterator.ORDERED), false);
- }
-
- public static DOTExporter defaultExporter() {
- DOTExporter exporter = new DOTExporter<>(id -> id);
- exporter.setVertexAttributeProvider((v) -> {
- Map map = new LinkedHashMap<>();
- map.put(LABEL, DefaultAttribute.createAttribute(v));
- return map;
- });
- return exporter;
- }
-
- public static DOTExporter coloredExporter() {
- DOTExporter exporter = new DOTExporter<>(ColoredNode::getLabel);
- exporter.setVertexAttributeProvider((v) -> {
- Map map = new LinkedHashMap<>();
- map.put(LABEL, DefaultAttribute.createAttribute(v.getLabel()));
- map.put(STYLE, DefaultAttribute.createAttribute(FILLED));
- map.put(FILLCOLOR, DefaultAttribute.createAttribute(v.getColor()));
- return map;
- });
- return exporter;
- }
-
-}
diff --git a/src/main/java/gr/gousiosg/javacg/stat/JCallGraph.java b/src/main/java/gr/gousiosg/javacg/stat/JCallGraph.java
index 38818d5f..c8bacbaf 100644
--- a/src/main/java/gr/gousiosg/javacg/stat/JCallGraph.java
+++ b/src/main/java/gr/gousiosg/javacg/stat/JCallGraph.java
@@ -28,123 +28,535 @@
package gr.gousiosg.javacg.stat;
-import gr.gousiosg.javacg.stat.support.Arguments;
-import gr.gousiosg.javacg.stat.support.coverage.ColoredNode;
-import gr.gousiosg.javacg.stat.support.coverage.CoverageStatistics;
-import gr.gousiosg.javacg.stat.support.coverage.JacocoCoverage;
+import edu.uic.bitslab.callgraph.GetBest;
+import gr.gousiosg.javacg.dyn.Pair;
+import gr.gousiosg.javacg.stat.coverage.ColoredNode;
+import gr.gousiosg.javacg.stat.coverage.CoverageStatistics;
+import gr.gousiosg.javacg.stat.coverage.JacocoCoverage;
+import gr.gousiosg.javacg.stat.graph.*;
+import gr.gousiosg.javacg.stat.support.BuildArguments;
+import gr.gousiosg.javacg.stat.support.GitArguments;
+import gr.gousiosg.javacg.stat.support.RepoTool;
+import gr.gousiosg.javacg.stat.support.TestArguments;
+import org.apache.bcel.classfile.ClassParser;
+import org.apache.bcel.classfile.JavaClass;
+import org.apache.bcel.classfile.Method;
+import org.apache.bcel.generic.Type;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.api.errors.JGitInternalException;
import org.jgrapht.Graph;
import org.jgrapht.graph.DefaultEdge;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
import javax.xml.bind.JAXBException;
import javax.xml.parsers.ParserConfigurationException;
-import java.io.IOException;
-import java.util.InputMismatchException;
-import java.util.Optional;
+import java.io.*;
+import java.util.*;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarInputStream;
+
+import static java.util.Map.entry;
/**
- * Constructs a callgraph out of a JAR archive. Can combine multiple archives
- * into a single call graph.
+ * Constructs a callgraph out of a JAR archive. Can combine multiple archives into a single call
+ * graph.
*
* @author Georgios Gousios
* @author Will Cygan
+ * @author Alekh Meka
*/
public class JCallGraph {
- private static final Logger LOGGER = LoggerFactory.getLogger(JCallGraph.class);
-
- public static final String OUTPUT_DIRECTORY = "./output/";
- private static final String REACHABILITY = "reachability";
- private static final String COVERAGE = "coverage";
- private static final String ANCESTRY = "ancestry";
- private static final String DELIMITER = "-";
- private static final String DOT_SUFFIX = ".dot";
- private static final String CSV_SUFFIX = ".csv";
-
- public static void main(String[] args) {
- try {
- LOGGER.info("Starting java-cg!");
- Arguments arguments = new Arguments(args);
- Graph graph = GraphUtils.staticCallgraph(arguments.getJars());
- JacocoCoverage jacocoCoverage = new JacocoCoverage(arguments.maybeCoverage());
-
- /* Should we store the graph in a file? */
- if (arguments.maybeOutput().isPresent()) {
- GraphUtils.writeGraph(graph, GraphUtils.defaultExporter(), arguments.maybeOutput().map(JCallGraph::asDot));
+ public static final String OUTPUT_DIRECTORY = "./output/";
+ private static final Logger LOGGER = LoggerFactory.getLogger(JCallGraph.class);
+ private static final String REACHABILITY = "reachability";
+ private static final String COVERAGE = "coverage";
+ private static final String ANCESTRY = "ancestry";
+ private static final String DELIMITER = "-";
+ private static final String DOT_SUFFIX = ".dot";
+ private static final String CSV_SUFFIX = ".csv";
+ private static final String SER_SUFFIX = ".ser";
+
+ public static void main(String[] args) {
+ try {
+ LOGGER.info("Starting java-cg!");
+ switch(args[0]){
+ case "manual-test": {
+ manualMain(args);
+ return;
+ }
+ case "git":{
+ GitArguments arguments = new GitArguments(args);
+ RepoTool rt = maybeObtainTool(arguments);
+ rt.cloneRepo();
+ rt.applyPatch();
+ rt.buildJars();
+ break;
+ }
+ case "build": {
+ // Build and serialize a staticcallgraph object with jar files provided
+ BuildArguments arguments = new BuildArguments(args);
+ StaticCallgraph callgraph = StaticCallgraph.build(arguments);
+ callgraph.JarEntry=arguments.getJars().get(0).first;
+ maybeSerializeStaticCallGraph(callgraph, arguments);
+ break;
+ }
+ case "buildyaml":{
+ DumperOptions options = new DumperOptions();
+ options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+ options.setPrettyFlow(true);
+ Yaml yaml = new Yaml(options);
+
+ JarInputStream jarFileStream = new JarInputStream(new FileInputStream(args[1]));
+ JarFile jarFile = new JarFile(args[1]);
+
+ ArrayList listOfAllClasses = getAllClassesFromJar(jarFileStream);
+ ArrayList> nameEntryList = new ArrayList<>();
+ for (JarEntry entry : listOfAllClasses)
+ nameEntryList.addAll(fetchAllMethodSignaturesForyaml(jarFile,entry));
+ ArrayList> entryResult = new ArrayList<>();
+
+ for(Pair entry : nameEntryList)
+ entryResult.add(Map.ofEntries(entry("name",entry.first),entry("entryPoint",entry.second)));
+
+ Map>> dataMap = new HashMap<>();
+ dataMap.put("properties",entryResult);
+ final FileWriter writer = new FileWriter(args[2]+".yaml");
+ yaml.dump(dataMap, writer);
+ break;
+ }
+ case "test": {
+ TestArguments arguments = new TestArguments(args);
+ String entryPoint = null;
+ // 1. Run Tests and obtain coverage
+ RepoTool rt = maybeObtainTool(arguments);
+ StaticCallgraph callgraph = deserializeStaticCallGraph(arguments);
+ List> coverageFilesAndEntryPointsShorthand = rt.obtainCoverageFilesAndEntryPoints();
+ List> coverageFilesAndEntryPoints=new ArrayList<>();
+ for(Pair s : coverageFilesAndEntryPointsShorthand) {
+ Pair result=new Pair<>(s.first,null);
+ if(s.second instanceof String){
+ entryPoint= (String) s.second;
}
+ else if(s.second instanceof ArrayList){
+ try {
+ Optional returnType = Optional.empty();
+ if(((ArrayList) s.second).size() > 1)
+ returnType = Optional.of(((ArrayList) s.second).get(1).toString());
- /* Should we compute reachability from the entry point? */
- if (arguments.maybeEntryPoint().isPresent()) {
- inspectReachability(graph, arguments, jacocoCoverage, arguments.maybeEntryPoint().get());
+ // Seventh argument, optional, parameter types of expected method
+ Optional paramterTypes = Optional.empty();
+ if(((ArrayList) s.second).size() > 2)
+ paramterTypes = Optional.of(((ArrayList) s.second).get(2).toString());
+
+ entryPoint = generateEntryPoint(callgraph.JarEntry, (String) ((ArrayList) s.second).get(0), returnType, paramterTypes);
+ } catch(IOException e){
+ LOGGER.error("Could not generate method signature", e);
+ }
}
+ LOGGER.info("Entry point inferred for name \n"+s.first.substring(s.first.lastIndexOf("/")+1)+" is\n "+entryPoint);
+ result.second=entryPoint;
+ coverageFilesAndEntryPoints.add(result);
+ }
+
+ for(Pair s : coverageFilesAndEntryPoints) {
+ // 2. For each coverage file we start with a fresh deserialized callgraph
+ callgraph = deserializeStaticCallGraph(arguments);
+ LOGGER.info("----------PROPERTY------------");
+ String propertyName = s.first.substring(s.first.lastIndexOf("/") + 1, s.first.length() - 4);
+ LOGGER.info(propertyName);
+ rt.testProperty(propertyName);
+ JacocoCoverage jacocoCoverage = new JacocoCoverage(s.first);
+ // 3. Prune the graph with coverage
+ Pruning.pruneOriginalGraph(callgraph, jacocoCoverage);
+ // 4. Operate on the graph and write it to output
+ maybeWriteGraph(callgraph.graph, JCallGraph.OUTPUT_DIRECTORY + propertyName);
+ Graph prunedReachability = maybeInspectReachability(callgraph, arguments.maybeDepth(), jacocoCoverage, s.second, JCallGraph.OUTPUT_DIRECTORY + propertyName);
+ maybeInspectAncestry(callgraph, arguments, jacocoCoverage, Optional.of(s.second), Optional.of(propertyName));
- /* Should we compute ancestry from the entry point? */
- if (arguments.maybeAncestry().isPresent()) {
- inspectAncestry(graph, arguments, jacocoCoverage, arguments.maybeEntryPoint().get(), arguments.maybeAncestry().get());
+ try {
+ // write the best paths and annotated dot file
+ GetBest getBest = new GetBest(prunedReachability, propertyName);
+ getBest.run();
+ } catch (NullPointerException e) {
+ // ok ... getbest blew up ... log it an continue
+ LOGGER.error("Get Best Null Pointer Exception: " + Arrays.stream(e.getStackTrace()).map(StackTraceElement::toString));
}
- } catch (InputMismatchException e) {
- LOGGER.error("Unable to load callgraph: " + e.getMessage());
- System.exit(1);
- } catch (ParserConfigurationException | SAXException | JAXBException |IOException e) {
- LOGGER.error("Error fetching Jacoco coverage");
- System.exit(1);
+ try {
+ rt.moveOutput();
+ } catch (Exception exception) {
+ LOGGER.error("Error moving output to artifact: " + exception.getMessage());
+ System.exit(1);
+ }
+ rt.cleanTarget();
+ }
+ break;
}
- LOGGER.info("java-cg is finished! Enjoy!");
+ default:
+ LOGGER.error("Invalid argument provided!");
+ System.exit(1);
+ }
+ } catch (InputMismatchException e) {
+ LOGGER.error("Unable to load callgraph: " + e.getMessage());
+ System.exit(1);
+ } catch(JGitInternalException e){
+ LOGGER.error("Cloned directory already exists!");
+ System.exit(1);
+ } catch(FileNotFoundException e){
+ LOGGER.error("Error obtaining valid yaml folder path: " + e.getMessage());
+ System.exit(1);
+ } catch (ParserConfigurationException | SAXException | JAXBException | IOException e) {
+ LOGGER.error("Error fetching Jacoco coverage: " + e.getMessage());
+ System.exit(1);
+ } catch(ClassNotFoundException e){
+ LOGGER.error("Error creating class through deserialization");
+ System.exit(1);
+ } catch (GitAPIException e) {
+ LOGGER.error("Error cloning repository");
+ System.exit(1);
+ } catch (InterruptedException e) {
+ LOGGER.error("Interrupted during applying patches/building jars");
+ System.exit(1);
}
- public static void inspectReachability(Graph graph, Arguments arguments, JacocoCoverage jacocoCoverage, String entryPoint) {
- /* Fetch reachability */
- Graph reachability = GraphUtils.reachability(graph, entryPoint, arguments.maybeDepth());
+ LOGGER.info("java-cg is finished! Enjoy!");
- /* Apply coverage */
- jacocoCoverage.applyCoverage(reachability);
+ }
- /* Should we write the graph to a file? */
- Optional outputName = arguments.maybeOutput().isPresent()
- ? Optional.of(arguments.maybeOutput().get() + DELIMITER + REACHABILITY)
- : Optional.empty();
+ //Main function to convert class.method arg and generate its respective method signature
+ public static String generateEntryPoint(String jarPath, String shortName, Optional returnType, Optional parameterTypes) throws IOException {
+ JarFile jarFile = new JarFile(jarPath);
+ JarInputStream jarFileStream = new JarInputStream(new FileInputStream(jarPath));
- /* Attach depth to name if present */
- outputName = outputName.map(name -> {
- if (arguments.maybeDepth().isPresent()) {
- return name + DELIMITER + arguments.maybeDepth().get();
- } else {
- return name;
- }
- });
+ String methodName = shortName.substring(shortName.lastIndexOf('.') + 1);
+ String className = shortName.substring(0, shortName.lastIndexOf('.'));
+ ArrayList listOfFilteredClasses = getAllClassesFromJar(jarFileStream);
+ className = className.replaceAll("\\.", "/") + ".class";
- /* Store reachability in file? */
- if (outputName.isPresent()) {
- GraphUtils.writeGraph(reachability, GraphUtils.coloredExporter(), outputName.map(JCallGraph::asDot));
- }
+ listOfFilteredClasses = getFilteredClassesFromJar(listOfFilteredClasses, className);
- /* Analyze reachability coverage? */
- if (jacocoCoverage.hasCoverage()) {
- CoverageStatistics.analyze(reachability, outputName.map(name -> asCsv(name + DELIMITER + COVERAGE)));
- }
+ if(listOfFilteredClasses.size() > 1) {
+ LOGGER.error("Multiple class instances found as listed below:- ");
+ for(JarEntry entry : listOfFilteredClasses)
+ LOGGER.error(entry.getName());
+ System.exit(1);
+ }
+ if(listOfFilteredClasses.size()==0){
+ LOGGER.error("no class instances found ");
+ System.exit(1);
}
- public static void inspectAncestry(Graph graph, Arguments arguments, JacocoCoverage jacocoCoverage, String entryPoint, int ancestryDepth) {
- Graph ancestry = GraphUtils.ancestry(graph, entryPoint, ancestryDepth);
- jacocoCoverage.applyCoverage(ancestry);
+ return fetchMethodSignatures(jarFile, listOfFilteredClasses.get(0), methodName, returnType, parameterTypes);
+
+ }
+
+ //Fetch JarEntry of all classes in a Jan using JarInputStream
+ public static ArrayList getAllClassesFromJar(JarInputStream JarInputStream) throws IOException {
+ JarEntry jar;
+ ArrayList listOfAllClasses = new ArrayList<>();
+ while(true) {
+ jar = JarInputStream.getNextJarEntry();
+ if(jar == null)
+ break;
+ if((jar.getName().endsWith(".class")))
+ listOfAllClasses.add(jar);
+ }
+ return listOfAllClasses;
+ }
- /* Should we store the ancestry in a file? */
- if (arguments.maybeOutput().isPresent()) {
- String subgraphOutputName = arguments.maybeOutput().get() + DELIMITER + ANCESTRY + DELIMITER + ancestryDepth;
- GraphUtils.writeGraph(ancestry, GraphUtils.coloredExporter(), Optional.of(asDot(subgraphOutputName)));
+ //Fetch filtered classes from a list of JarEntry
+ public static ArrayList getFilteredClassesFromJar(ArrayList listOfAllClasses, String className) {
+ ArrayList listOfFilteredClasses= new ArrayList<>();
+ for (JarEntry entry : listOfAllClasses)
+ if (entry.getName().endsWith(className))
+ listOfFilteredClasses.add(entry);
+ return listOfFilteredClasses;
+ }
+public static ArrayList> fetchAllMethodSignaturesForyaml (JarFile JarFile,JarEntry jar) throws IOException {
+ ClassParser cp = new ClassParser(JarFile.getInputStream(jar), jar.getName());
+ JavaClass jc = cp.parse();
+
+ Method[] methods = jc.getMethods();
+ String className =jc.getClassName().substring(jc.getClassName().lastIndexOf(".")+1);
+ ArrayList> signatureResults = new ArrayList<>();
+ for(Method tempMethod : methods)
+ if(Arrays.stream(tempMethod.getAnnotationEntries())
+ .map(e->e.getAnnotationType())
+ .anyMatch(e->e.equals("Lcom/pholser/junit/quickcheck/Property;"))){ // .anyMatch(e->e.equals("Lorg/junit/Test;"))){
+ String methodDescriptor=tempMethod.getName() + tempMethod.getSignature();
+ signatureResults.add(new Pair<>(className+"#"+tempMethod.getName(),jc.getClassName() + "." + methodDescriptor));
+ }
+ return signatureResults;
+}
+ //Fetch the method signature of a method from a JarEntry
+ public static String fetchMethodSignatures(JarFile JarFile, JarEntry jar, String methodName, Optional returnType, Optional paramterTypes) throws IOException {
+ ClassParser cp = new ClassParser(JarFile.getInputStream(jar), jar.getName());
+ JavaClass jc = cp.parse();
+
+ Method[] methods = jc.getMethods();
+ ArrayList signatureResults = new ArrayList<>();
+
+ for(Method tempMethod : methods)
+ if(tempMethod.getName().equals(methodName))
+ signatureResults.add(tempMethod);
+
+ if(returnType.isPresent()) {
+ ArrayList tempsignatureResults = new ArrayList<>();
+ for(Method tempMethod : signatureResults)
+ if(tempMethod.getReturnType().toString().contains(returnType.get()))
+ tempsignatureResults.add(tempMethod);
+ signatureResults=new ArrayList<>(tempsignatureResults);
+
+ if(paramterTypes.isPresent()) {
+ String[] paramlist = paramterTypes.get().split(",");
+ for(Method tempMethod : signatureResults)
+ if(Arrays.equals(paramlist, Arrays.stream(tempMethod.getArgumentTypes())
+ .map(Type::toString)
+ .map(e -> e.substring(e.lastIndexOf(".") + 1))
+ .toArray()))
+ return jc.getClassName() + "." + tempMethod.getName() + tempMethod.getSignature();
+ }
+ validateMethodList(signatureResults);
+ return jc.getClassName() + "." + signatureResults.get(0).getName() + signatureResults.get(0).getSignature();
+ } else {
+ validateMethodList(signatureResults);
+ return jc.getClassName() + "." + signatureResults.get(0).getName() + signatureResults.get(0).getSignature();
+ }
+ }
+
+ // Check the size of list and submit Logger info for the methods
+ public static void validateMethodList(ArrayList methodList) {
+ if(methodList.size() > 1) {
+ LOGGER.error("Multiple overloaded methods for the given method name");
+ for(Method method : methodList) {
+ LOGGER.info("Name:- " + method.getName() + " Return Type:- " + method.getReturnType().toString());
+ LOGGER.info("Parameter Types:- ");
+ for(Type t : method.getArgumentTypes()) {
+ LOGGER.info(t.toString());
}
+ method.getArgumentTypes();
+ }
+ System.exit(1);
+ } else if(methodList.size() == 0) {
+ LOGGER.info("Incorrect arguments supplied");
+ System.exit(1);
}
+ }
+
+ public static void manualMain(String[] args) {
- private static String asDot(String name) {
- return name.endsWith(DOT_SUFFIX) ? name : (name + DOT_SUFFIX);
+ // First argument: the serialized file
+ StaticCallgraph callgraph = null;
+ try {
+ File f = new File(args[1]);
+ LOGGER.info("Deserializing file " + f.getAbsolutePath());
+ callgraph = deserializeStaticCallGraph(new File(args[1]));
+ } catch (IOException e) {
+ LOGGER.error("Could not deserialize static call graph", e);
+ } catch (ClassNotFoundException e) {
+ LOGGER.error("This shouldn't happen, go fix your CLASSPATH", e);
}
- private static String asCsv(String name) {
- return name.endsWith(CSV_SUFFIX) ? name : (name + CSV_SUFFIX);
+ // Second argument: the jacoco.xml
+ JacocoCoverage jacocoCoverage = null;
+ try {
+ File f = new File(args[2]);
+ LOGGER.info("Reading JaCoCo coverage file " + f.getAbsolutePath());
+ jacocoCoverage = new JacocoCoverage(f.getAbsolutePath());
+ } catch (IOException | ParserConfigurationException | JAXBException | SAXException e) {
+ LOGGER.error("Could not read JaCoCo coverage file", e);
+ }
+
+ // third argument: the output file
+ String output = args[3];
+
+ if (callgraph == null || jacocoCoverage == null) {
+ // Something went wrong, bail
+ return;
+ }
+
+ // forth argument: Jar path to infer entry point signature
+ String jarPath = args[4];
+ try {
+ new JarFile(jarPath);
+ } catch(IOException e){
+ LOGGER.error("Could not read inference Jar file", e);
+ }
+
+ // Sixth argument, optional, return type of expected method
+ Optional returnType = Optional.empty();
+ if(args.length > 6)
+ returnType = Optional.of(args[6]);
+
+ // Seventh argument, optional, parameter types of expected method
+ Optional paramterTypes = Optional.empty();
+ if(args.length > 7)
+ paramterTypes = Optional.of(args[7]);
+
+ // Fifth argument, class.method input where class can be written as nested classes to generate exact method signature
+ String entryPoint = null;
+ try {
+ entryPoint = generateEntryPoint(jarPath, args[5], returnType, paramterTypes);
+// System.out.println(entryPoint);
+ } catch(IOException e){
+ LOGGER.error("Could not generate method signature", e);
}
+
+ // Seventh argument, optional, is the depth
+ Optional depth = Optional.empty();
+// if (args.length > 6)
+// depth = Optional.of(Integer.parseInt(args[7]));
+
+ // This method changes the callgraph object
+ Pruning.pruneOriginalGraph(callgraph, jacocoCoverage);
+
+ maybeInspectReachability(callgraph, depth, jacocoCoverage, entryPoint, output);
+
+ // maybeWriteGraph(callgraph.graph, args[4]);
+ }
+
+ private static void maybeWriteGraph(Graph graph, String output) {
+ Utilities.writeGraph(graph, Utilities.defaultExporter(), JCallGraph.asDot(output));
+ }
+
+ private static Graph maybeInspectReachability(
+ StaticCallgraph callgraph, Optional depth, JacocoCoverage jacocoCoverage, String entryPoint, String outputFile) {
+
+ /* Fetch reachability */
+ Graph reachability =
+ Reachability.compute(
+ callgraph.graph, entryPoint, depth);
+
+ /* Apply coverage */
+ jacocoCoverage.applyCoverage(reachability, callgraph.metadata);
+
+ Pruning.pruneReachabilityGraph(reachability, callgraph.metadata, jacocoCoverage);
+
+ /* Should we write the graph to a file? */
+ String outputName = getCompleteOutputName(depth, outputFile);
+
+ /* Store reachability in file? */
+ Utilities.writeGraph(
+ reachability, Utilities.coloredExporter(), JCallGraph.asDot(outputName));
+
+ try {
+ writeSerializeReachabilityGraph(reachability, asSer(outputName));
+ } catch (IOException e) {
+ LOGGER.error("Error writing serialized reachability graph.");
+ LOGGER.error(e.getMessage());
+ }
+
+
+ /* Analyze reachability coverage? */
+ if (jacocoCoverage.hasCoverage()) {
+ CoverageStatistics.analyze( reachability, Optional.of(asCsv(outputName + DELIMITER + COVERAGE)));
+ }
+
+ return reachability;
+ }
+
+ private static String getCompleteOutputName(Optional depth, String outputFile) {
+ /* Should we write the graph to a file? */
+ String outputName = outputFile + DELIMITER + REACHABILITY;
+
+ /* Attach depth to name if present */
+ if (depth.isPresent()) {
+ outputName = outputName + DELIMITER + depth.get();
+ }
+
+ return outputName;
+ }
+
+ private static void maybeInspectAncestry(
+ StaticCallgraph callgraph, TestArguments arguments, JacocoCoverage jacocoCoverage, Optional entryPoint, OptionaloutputName) {
+ if (arguments.maybeAncestry().isEmpty() || entryPoint.isEmpty()) {
+ return;
+ }
+
+ Graph ancestry =
+ Ancestry.compute(
+ callgraph.graph, entryPoint.get(), arguments.maybeAncestry().get());
+ jacocoCoverage.applyCoverage(ancestry, callgraph.metadata);
+
+ /* Should we store the ancestry in a file? */
+ if (outputName.isPresent()) {
+ String subgraphOutputName =
+ outputName.get()
+ + DELIMITER
+ + ANCESTRY
+ + DELIMITER
+ + arguments.maybeAncestry().get();
+ Utilities.writeGraph(
+ ancestry, Utilities.coloredExporter(), JCallGraph.OUTPUT_DIRECTORY + asDot(subgraphOutputName));
+ }
+ }
+
+ private static String asDot(String name) {
+ return name.endsWith(DOT_SUFFIX) ? name : (name + DOT_SUFFIX);
+ }
+
+ private static String asSer(String name) {
+ return name.endsWith(SER_SUFFIX) ? name : (name + SER_SUFFIX);
+ }
+
+ private static String asCsv(String name) {
+ return name.endsWith(CSV_SUFFIX) ? name : (name + CSV_SUFFIX);
+ }
+
+ //
+ // serializeStaticCallGraph creates a file that contains the bytecode data of the StaticCallgraph object
+ // Throws: IOException when the file cannot be written to disk
+ private static void maybeSerializeStaticCallGraph(StaticCallgraph callgraph, BuildArguments arguments) throws IOException{
+ if(arguments.maybeOutput().isPresent()) {
+ File filename = new File(arguments.maybeOutput().get());
+ FileOutputStream file = new FileOutputStream(filename);
+ ObjectOutputStream out = new ObjectOutputStream(file);
+ out.writeObject(callgraph);
+ out.close();
+ file.close();
+ }
+ }
+
+ private static void writeSerializeReachabilityGraph(Graph reachability, String pathname) throws IOException {
+ File filename = new File(pathname);
+ FileOutputStream file = new FileOutputStream(filename);
+ ObjectOutputStream out = new ObjectOutputStream(file);
+ out.writeObject(reachability);
+ out.close();
+ file.close();
+ }
+
+ //
+ // deserializeStaticCallGraph reads bytecode and creates a StaticCallgraph object to be returned
+ // Throws: IOException when file cannot be read
+ // Throws: ClassNotFoundException when object cannot be read properly
+ private static StaticCallgraph deserializeStaticCallGraph(TestArguments arguments) throws IOException, ClassNotFoundException{
+ return deserializeStaticCallGraph(new File(arguments.maybeBytecodeFile().get()));
+ }
+
+ private static StaticCallgraph deserializeStaticCallGraph(File f) throws IOException, ClassNotFoundException{
+ try (ObjectInput ois = new ObjectInputStream(new FileInputStream(f))) {
+ return (StaticCallgraph) ois.readObject();
+ }
+ }
+
+
+ private static RepoTool maybeObtainTool(GitArguments arguments) throws FileNotFoundException{
+ Optional rt = RepoTool.obtainTool(arguments.maybeGetConfig().get());
+ if(rt.isPresent())
+ return rt.get();
+ throw new FileNotFoundException("folderName path is incorrect! Please provide a valid folder");
+ }
+
+ private static RepoTool maybeObtainTool(TestArguments arguments) throws FileNotFoundException{
+ return new RepoTool(arguments.maybeGetConfig().get());
+ }
}
diff --git a/src/main/java/gr/gousiosg/javacg/stat/MethodVisitor.java b/src/main/java/gr/gousiosg/javacg/stat/MethodVisitor.java
index 9e13d062..304a39f0 100644
--- a/src/main/java/gr/gousiosg/javacg/stat/MethodVisitor.java
+++ b/src/main/java/gr/gousiosg/javacg/stat/MethodVisitor.java
@@ -39,32 +39,33 @@
import java.lang.reflect.Method;
import java.util.*;
+import java.util.stream.Collectors;
import static gr.gousiosg.javacg.stat.support.IgnoredConstants.IGNORED_METHOD_NAMES;
/**
- * The simplest of method visitors, prints any invoked method
- * signature for all method invocations.
- *
- * Class copied with modifications from CJKM: http://www.spinellis.gr/sw/ckjm/
+ * The simplest of method visitors, prints any invoked method signature for all method invocations.
+ *
+ * Class copied with modifications from CJKM: http://www.spinellis.gr/sw/ckjm/
*/
public class MethodVisitor extends EmptyVisitor {
private static final Logger LOGGER = LoggerFactory.getLogger(MethodVisitor.class);
private static final Boolean EXPAND = true;
private static final Boolean DONT_EXPAND = false;
-
+ private final JarMetadata jarMetadata;
JavaClass visitedClass;
+ private boolean isTestMethod;
private MethodGen mg;
private ConstantPoolGen cp;
private String format;
-
- // methodCalls helps us build the (caller -> receiver) call graph
private Set> methodCalls = new HashSet<>();
- private final JarMetadata jarMetadata;
+ private Map, Map>> expansions = new HashMap<>();
+ private int currentLineNumber = -1;
- public MethodVisitor(MethodGen m, JavaClass jc, JarMetadata jarMetadata) {
+ public MethodVisitor(MethodGen m, JavaClass jc, JarMetadata jarMetadata, boolean isTestMethod) {
this.jarMetadata = jarMetadata;
+ this.isTestMethod = isTestMethod;
visitedClass = jc;
mg = m;
cp = mg.getConstantPool();
@@ -82,24 +83,101 @@ private String argumentList(Type[] arguments) {
return sb.toString();
}
- public Set> start() {
- if (mg.isAbstract() || mg.isNative())
- return Collections.emptySet();
+ private LinkedList findLeaders(InstructionList il) {
+ // https://www.geeksforgeeks.org/basic-blocks-in-compiler-design/
+ LinkedList is = new LinkedList<>();
+ Set leaders = new HashSet<>();
- for (InstructionHandle ih = mg.getInstructionList().getStart();
- ih != null; ih = ih.getNext()) {
+ leaders.add(il.getStart());
+
+ for (InstructionHandle ih = il.getStart(); ih != null; ih = ih.getNext()) {
+ is.addLast(ih);
Instruction i = ih.getInstruction();
-
- if (!visitInstruction(i))
- i.accept(this);
+
+ if (i instanceof IfInstruction) {
+ IfInstruction ifi = (IfInstruction) i;
+ leaders.add(ifi.getTarget());
+ leaders.add(ih.getNext());
+ } else if (i instanceof GOTO) {
+ // TODO unconditional GOTOs
+ } else if (i instanceof Select) {
+ // TODO switch-case
+ } else if (i instanceof ReturnInstruction || i instanceof ATHROW) {
+ if (ih.getNext() != null)
+ leaders.add(ih.getNext());
+ }
}
+
+ LinkedList sortedLeaders = new LinkedList<>(leaders);
+ Collections.sort(sortedLeaders, Comparator.comparingInt(InstructionHandle::getPosition));
+
+ return sortedLeaders;
+ }
+
+ private List> computeBasicBlocks(InstructionList il) {
+ LinkedList leaders = findLeaders(il);
+
+ LinkedList> ret = new LinkedList<>();
+
+ LinkedList currentBlock = new LinkedList<>();
+
+ {
+ // First instruction is always a leader, add manually
+ leaders.removeFirst();
+ currentBlock.addLast(il.getStart());
+ }
+
+ for (InstructionHandle ih = il.getStart().getNext(); ih != null; ih = ih.getNext()) {
+ if (!leaders.isEmpty() && ih == leaders.getFirst()) {
+ // Found start of next BB
+ ret.addLast(currentBlock);
+ currentBlock = new LinkedList<>();
+ currentBlock.addLast(ih);
+ leaders.removeFirst();
+ } else {
+ // Regular instruction, just add to current block
+ currentBlock.addLast(ih);
+ }
+ }
+
+ // Add last BB
+ ret.addLast(currentBlock);
+
+ return ret;
+ }
+
+ public Set> start() {
+ if (mg.isAbstract() || mg.isNative()) return Collections.emptySet();
+
+ boolean includeExceptionBasicBlocks = Boolean.getBoolean("jcg.includeExceptionBasicBlocks");
+
+ List> bbs = this.computeBasicBlocks(mg.getInstructionList());
+
+ for (LinkedList bb : bbs) {
+ if (!includeExceptionBasicBlocks && bb.getLast().getInstruction() instanceof ATHROW) {
+ // skip BBs that throw exceptions
+ continue;
+ }
+
+ for (InstructionHandle ih : bb) {
+ Instruction i = ih.getInstruction();
+
+ if (!visitInstruction(i)) {
+ int currentBytecodeOffset = ih.getPosition();
+ currentLineNumber = mg.getLineNumberTable(cp).getSourceLine(currentBytecodeOffset);
+ i.accept(this);
+ }
+
+ }
+ }
+
return methodCalls;
}
private boolean visitInstruction(Instruction i) {
short opcode = i.getOpcode();
return ((InstructionConst.getInstruction(opcode) != null)
- && !(i instanceof ConstantPushInstruction)
+ && !(i instanceof ConstantPushInstruction)
&& !(i instanceof ReturnInstruction));
}
@@ -129,77 +207,140 @@ public void visitINVOKEDYNAMIC(INVOKEDYNAMIC i) {
}
private void visit(InvokeInstruction i, Boolean shouldExpand) {
- /* caller method info */
- String callerClassType = visitedClass.getClassName();
- String callerMethodName = mg.getName();
- Type[] callerArgumentTypes = mg.getArgumentTypes();
- Type callerReturnType = mg.getReturnType();
- String callerSignature = MethodSignatureUtil.fullyQualifiedMethodSignature(callerClassType, callerMethodName, callerArgumentTypes, callerReturnType);
-
- /* receiver method info */
- String receiverClassType = String.format(format, i.getReferenceType(cp));
- String receiverMethodName = i.getMethodName(cp);
- Type[] receiverArgumentTypes = i.getArgumentTypes(cp);
- Type receiverReturnType = i.getReturnType(cp);
- String receiverSignature = MethodSignatureUtil.fullyQualifiedMethodSignature(receiverClassType, receiverMethodName, receiverArgumentTypes, receiverReturnType);
-
- /* Record initial method call */
- methodCalls.add(createEdge(callerSignature, receiverSignature));
-
- if (shouldExpand && !IGNORED_METHOD_NAMES.contains(receiverMethodName)) {
- Optional> maybeReceiverType = jarMetadata.getClass(receiverClassType);
+ Node caller = new Node(mg, visitedClass);
+ Node receiver = new Node(i, cp, format);
+ methodCalls.add(createEdge(caller.signature, receiver.signature));
+
+ if (isTestMethod) {
+ jarMetadata.testMethods.add(caller.signature);
+ }
+
+ // save the line number and method call
+ jarMetadata.impliedMethodCalls.putIfAbsent(receiver.signature, new HashSet<>());
+ jarMetadata
+ .impliedMethodCalls
+ .get(receiver.signature)
+ .add(filenameAndLineNumber(visitedClass.getSourceFileName(), currentLineNumber));
+
+ // decide if we should look at a potential expansion
+ if (shouldExpand && !IGNORED_METHOD_NAMES.contains(receiver.method)) {
+
+ // get the class types
+ Optional> maybeReceiverType = jarMetadata.getClass(receiver.clazz);
+ Optional
