Class Hierarchy Analysis Research Articles

Frankenstein: fast and lightweight call graph generation for software builds

Call Graphs are a rich data source and form the foundation for advanced static analyses that can, for example, detect security vulnerabilities or dead code. This information is invaluable when it is immediately available, such as in the output of a build system. Call Graph generation is a whole-program analysis: not just the application, but also all its dependencies are processed together. Recent work has shown that even advanced static analyses can use summarization techniques to substantially improve runtime; however, existing analyses focus on soundness, and as such remain very expensive. When executed in the build system, which typically has limited resources, even powerful servers suffer from slow build times, rendering these analyses impractical in today’s fast-paced development. In this paper, we aim to strike a balance between improving static analyses while remaining practical for use cases that require quick results in low-resource environments. We propose a summarization-based implementation of a Class-Hierarchy Analysis algorithm for call graph generation of Java programs. Our approach leverages the fact that dependency sets often do not change between builds: we can generate call graphs for these dependencies, cache their generation for subsequent builds, and using a novel stitching algorithm, Frankenstein, merge all partial results into a complete call graph for the whole program. Our evaluation results show that this lightweight approach can substantially outperform existing frameworks. In terms of speed improvements, Frankenstein surpasses the baselines by up to 38%, requiring an average of just 388 Megabytes of memory. This makes the proposed approach practical for build systems with limited memory resources. Despite these optimizations, our generated call graphs maintain a near-identical set of edges when compared to the baselines, achieving an F1\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$_{1}$$\\end{document} score of up to 0.98. This summarization-based approach for call graph generation paves the way for using extended static analyses in build processes.

TFA: an efficient and precise virtual methodcall resolution for Java

Abstract The problem of statically resolving virtual method calls in object-oriented (OO) programming languages has been a long standing challenge, often due to the overly complicated class hierarchy structures in modern OO programming languages such as Java, C# and C++. Traditional ways of dealing with this problem include class hierarchy analysis (CHA), variable type analysis (VTA), and retrieval of type information after a sophisticated points-to analysis. In this paper, we tackle this problem by proposing a new approach called type flow analysis (TFA) which propagates type information as well as field access information through the syntactic structure of a program. Our methodology is purely algebraic and there is no need to explicitly construct a heap abstraction. We have assessed our methodology from two perspectives. Regarding its theoretical foundation, we have proved that in the context insensitive setting, our method is as precise as the standard Andersen’s subset based points-to analysis regarding the derived types for variables. For an experimental evaluation of TFA, we have implemented the algorithm in the Soot framework and used it to analyze the SPECjvm2008 benchmark suite. During the experiment, we have shown that our method is usually 30–100 times faster than the standard points-to analysis. We further conduct a range of detailed analysis based on the baseline data obtained by running a dynamic profiler, which is also implemented by us, on the SPECjvm2008. The experiment results confirm that TFA can achieve outstanding performance with acceptable accuracy when applied on real-world Java programs.

Reusing Run-Time Type Identification (RTTI) Generated By Compiler For Construction Of The Class Hierarchy Graph (CHG)

In statically-typed object-oriented languages optimization plays an important role to make program compilation faster. A number of methods have been used, and a variety of algorithms have been suggested and designed for optimization of statically typed object-oriented languages like C++ and Java. One of the important considerations inoptimization of statically typed object-oriented language is function de-virtualization. Function de-virtualization converts virtual function calls to direct calls, i.e. a virtual function call is replaced by a call to the method of some class. The direct calls can be further inlined to enhance the performance. Class hierarchy Analysis (CHA) (3) is the well-known technique used to identify the virtual calls in a program that can be converted into direct calls. The class hierarchy Analysis starts with a building a Class Hierarchy Graph (CHG) that represents the relation between the various classes of program and the visible methods within these classes. In fact the most basic data structure for developing optimization algorithms is the CHG, which abstracts the Base-derived class relationship that use virtual functions. A number of algorithms have been designed for constructingClass Hierarchy Graph (CHG) like the one designed by Bacon, D.F (1) that uses the source level information to build CHG. Several alternatives have been presented to this approach as well. In this article we will present the method for construction of CHG by reusing the RTTI (RuntimeType Identification) generated by the complier. I. Introduction and Objectives:

Practical virtual method call resolution for Java

This paper addresses the problem of resolving virtual method and interface calls in Java bytecode. The main focus is on a new practical technique that can be used to analyze large applications. Our fundamental design goal was to develop a technique that can be solved with only one iteration, and thus scales linearly with the size of the program, while at the same time providing more accurate results than two popular existing linear techniques, class hierarchy analysis and rapid type analysis .We present two variations of our new technique, variable-type analysis and a coarser-grain version called declared-type analysis . Both of these analyses are inexpensive, easy to implement, and our experimental results show that they scale linearly in the size of the program.We have implemented our new analyses using the Soot frame-work, and we report on empirical results for seven benchmarks. We have used our techniques to build accurate call graphs for complete applications (including libraries) and we show that compared to a conservative call graph built using class hierarchy analysis, our new variable-type analysis can remove a significant number of nodes (methods) and call edges. Further, our results show that we can improve upon the compression obtained using rapid type analysis.We also provide dynamic measurements of monomorphic call sites, focusing on the benchmark code excluding libraries. We demonstrate that when considering only the benchmark code, both rapid type analysis and our new declared-type analysis do not add much precision over class hierarchy analysis. However, our finer-grained variable-type analysis does resolve significantly more call sites, particularly for programs with more complex uses of objects.

An inheritance flow model for class hierarchy analysis

This paper presents an inheritance flow model, which represents the inheritance relationships among classes as a flow graph. A flow operation is associated with each attribute and method in a class to denote the defined (redefined) or inherited member. An inherited member can be deemed as being handled by a sequence of flow operations along a path in the flow graph. This model provides several analyses in a class hierarchy, such as implicit inherited member and polymorphic method invocation. These analyses may be applied in various fields of software engineering, such as static analysis, maintenance, and complexity measurement.

Vortex

Previously, techniques such as class hierarchy analysis and profile-guided receiver class prediction have been demonstrated to greatly improve the performance of applications written in pure object-oriented languages, but the degree to which these results are transferable to applications written in hybrid languages has been unclear. In part to answer this question, we have developed the Vortex compiler infrastructure, a language-independent optimizing compiler for object-oriented languages, with front-ends for Cecil, C++, Java, and Modula-3. In this paper, we describe the Vortex compiler's intermediate language, internal structure, and optimization suite, and then we report the results of experiments assessing the effectiveness of different combinations of optimizations on sizable applications across these four languages. We characterize the benchmark programs in terms of a collection of static and dynamic metrics, intended to quantify aspects of the "object-orientedness" of a program.