Interprocedural optimization: eliminating unnecessary recompilation
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
Rigi-A system for programming-in-the-large
ICSE '88 Proceedings of the 10th international conference on Software engineering
Constructing the Procedure Call Multigraph
IEEE Transactions on Software Engineering
The C Information Abstraction System
IEEE Transactions on Software Engineering
ACM Letters on Programming Languages and Systems (LOPLAS)
Constructing call multigraphs using dependence graphs
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
How Accurate is Scientific Software?
IEEE Transactions on Software Engineering
An empirical study of static call graph extractors
Proceedings of the 18th international conference on Software engineering
Lightweight lexical source model extraction
ACM Transactions on Software Engineering and Methodology (TOSEM)
A practical interprocedural data flow analysis algorithm
Communications of the ACM
Efficient computation of flow insensitive interprocedural summary information
SIGPLAN '84 Proceedings of the 1984 SIGPLAN symposium on Compiler construction
The Field Programming Environment: A Friendly Integrated Environment for Learning and Development
The Field Programming Environment: A Friendly Integrated Environment for Learning and Development
A precise inter-procedural data flow algorithm
POPL '81 Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
An efficient way to find the side effects of procedure calls and the aliases of variables
POPL '79 Proceedings of the 6th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Gprof: A call graph execution profiler
SIGPLAN '82 Proceedings of the 1982 SIGPLAN symposium on Compiler construction
Fast, Flexible Syntactic Pattern Matching and Processing
WPC '96 Proceedings of the 4th International Workshop on Program Comprehension (WPC '96)
System-dependence-graph-based slicing of programs with arbitrary interprocedural control flow
Proceedings of the 21st international conference on Software engineering
Software Reflexion Models: Bridging the Gap between Design and Implementation
IEEE Transactions on Software Engineering
Using benchmarking to advance research: a challenge to software engineering
Proceedings of the 25th International Conference on Software Engineering
Precise Call Graphs for C Programs with Function Pointers
Automated Software Engineering
Delegation diagrams: visual support for the development of object-oriented designs
AUIC '04 Proceedings of the fifth conference on Australasian user interface - Volume 28
Hypertext support for the information needs of software maintainers
Journal of Software Maintenance and Evolution: Research and Practice
Exploiting UML dynamic object modeling for the visualization of C++ programs
SoftVis '05 Proceedings of the 2005 ACM symposium on Software visualization
Bridging the gap between technical and social dependencies with Ariadne
eclipse '05 Proceedings of the 2005 OOPSLA workshop on Eclipse technology eXchange
An infrastructure to support interoperability in reverse engineering
Information and Software Technology
Proceedings of the 2007 international ACM conference on Supporting group work
A tool chain for reverse engineering C++ applications
Science of Computer Programming
Proceedings of the Second ACM-IEEE international symposium on Empirical software engineering and measurement
DeFacto: Language-Parametric Fact Extraction from Source Code
Software Language Engineering
Discovery of architectural layers and measurement of layering violations in source code
Journal of Systems and Software
SEAFOOD'07 Proceedings of the 1st international conference on Software engineering approaches for offshore and outsourced development
Taming reflection: Aiding static analysis in the presence of reflection and custom class loaders
Proceedings of the 33rd International Conference on Software Engineering
Where is the energy spent inside my app?: fine grained energy accounting on smartphones with Eprof
Proceedings of the 7th ACM european conference on Computer Systems
Automated support for building behavioral models of event-driven systems
FASE'06 Proceedings of the 9th international conference on Fundamental Approaches to Software Engineering
System-specific static code analyses: a case study in the complex embedded systems domain
Software Quality Control
Combining lexical and structural information for static bug localisation
International Journal of Computer Applications in Technology
Language independent framework for static code analysis
Proceedings of the 6th Balkan Conference in Informatics
Portfolio: Searching for relevant functions and their usages in millions of lines of code
ACM Transactions on Software Engineering and Methodology (TOSEM) - Testing, debugging, and error handling, formal methods, lifecycle concerns, evolution and maintenance
Hi-index | 0.00 |
Informally, a call graph represents calls between entities in a given program. The call graphs that compilers compute to determine the applicability of an optimization must typically be conservative: a call may be omitted only if it can never occur in any execution of the program. Numerous software engineering tools also extract call graphs with the expectation that they will help software engineers increase their understanding of a program. The requirements placed on software engineeringtools that compute call graphs are typically more relaxed than for compilers. For example, some false negatives—calls that can in fact take place in some execution of the program, but which are omitted from the call graph—may be acceptable, depending on the understanding task at hand. In this article, we empirically show a consequence of this spectrum of requirements by comparing the C call graphs extracted from three software systems (mapmaker, mosaic, and gcc) by nine tools (cflow, cawk, CIA, Field, GCT, Imagix, LSME, Mawk, and Rigiparse). A quantitative analysis of the call graphs extracted for each system shows considerable variation, a result that is counterintuitive to many experienced software engineers. A qualitative analysis of these results reveals a number of reasons for this variation: differing treatments of macros, function pointers, input formats, etc. The fundamental problem is not that variances among the graphs extracted by different tools exist, but that software engineers have little sense of the dimensions of approximation in any particular call graph. In this article, we describe and discuss the study, sketch a design space for static call graph extractors, and discuss the impact of our study on practitioners, tool developers, and researchers. Although this article considers only one kind of information, call graphs, many of the observations also apply to static extractors of other kinds of information, such as inheritance structures, file dependences, and references to global variables.