Compilers: principles, techniques, and tools
Compilers: principles, techniques, and tools
Program evolution: processes of software change
Program evolution: processes of software change
The C programming language
The C++ programming language (2nd ed.)
The C++ programming language (2nd ed.)
Interprocedural modification side effect analysis with pointer aliasing
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
Context-sensitive interprocedural points-to analysis in the presence of function pointers
PLDI '94 Proceedings of the ACM SIGPLAN 1994 conference on Programming language design and implementation
Demand-driven computation of interprocedural data flow
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Context-insensitive alias analysis reconsidered
PLDI '95 Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation
Managing design trade-offs for a program understanding and transformation tool
Journal of Systems and Software - Double issue on reengineering complex systems
Demand interprocedural dataflow analysis
SIGSOFT '95 Proceedings of the 3rd ACM SIGSOFT symposium on Foundations of software engineering
The design of whole-program analysis tools
Proceedings of the 18th international conference on Software engineering
Points-to analysis in almost linear time
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Verification of communication protocols using data flow analysis
SIGSOFT '96 Proceedings of the 4th ACM SIGSOFT symposium on Foundations of software engineering
Fast and accurate flow-insensitive points-to analysis
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
On the criteria to be used in decomposing systems into modules
Communications of the ACM
The Effects of the Precision of Pointer Analysis
SAS '97 Proceedings of the 4th International Symposium on Static Analysis
The Interprocedural Coincidence Theorem
CC '92 Proceedings of the 4th International Conference on Compiler Construction
Points-to Analysis by Type Inference of Programs with Structures and Unions
CC '96 Proceedings of the 6th International Conference on Compiler Construction
Proceedings of the 1999 ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering
Efficient points-to analysis for whole-program analysis
ESEC/FSE-7 Proceedings of the 7th European software engineering conference held jointly with the 7th ACM SIGSOFT international symposium on Foundations of software engineering
Data-flow analysis of program fragments
ESEC/FSE-7 Proceedings of the 7th European software engineering conference held jointly with the 7th ACM SIGSOFT international symposium on Foundations of software engineering
Light-weight context recovery for efficient and accurate program analyses
Proceedings of the 22nd international conference on Software engineering
Which pointer analysis should I use?
Proceedings of the 2000 ACM SIGSOFT international symposium on Software testing and analysis
Unification-based pointer analysis with directional assignments
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Ultra-fast aliasing analysis using CLA: a million lines of C code in a second
Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation
Complexity of Points-To Analysis of Java in the Presence of Exceptions
IEEE Transactions on Software Engineering
Making slicing practical: the final mile
PASTE '01 Proceedings of the 2001 ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering
Pointer analysis: haven't we solved this problem yet?
PASTE '01 Proceedings of the 2001 ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering
A schema for interprocedural modification side-effect analysis with pointer aliasing
ACM Transactions on Programming Languages and Systems (TOPLAS)
Equivalence analysis and its application in improving the efficiency of program slicing
ACM Transactions on Software Engineering and Methodology (TOSEM)
Improving program slicing with dynamic points-to data
Proceedings of the 10th ACM SIGSOFT symposium on Foundations of software engineering
Improving program slicing with dynamic points-to data
ACM SIGSOFT Software Engineering Notes
Efficient Computation of Parameterized Pointer Information for Interprocedural Analyses
SAS '01 Proceedings of the 8th International Symposium on Static Analysis
Incremental Slicing Based on Data-Dependences Types
ICSM '01 Proceedings of the IEEE International Conference on Software Maintenance (ICSM'01)
Implementation Techniques for Efficient Data-Flow Analysis of Large Programs
ICSM '01 Proceedings of the IEEE International Conference on Software Maintenance (ICSM'01)
ACM Transactions on Software Engineering and Methodology (TOSEM)
Analysis and Visualization of Predicate Dependence on Formal Parameters and Global Variables
IEEE Transactions on Software Engineering
A brief survey of program slicing
ACM SIGSOFT Software Engineering Notes
Incremental and demand-driven points-to analysis using logic programming
PPDP '05 Proceedings of the 7th ACM SIGPLAN international conference on Principles and practice of declarative programming
Program Slicing with Dynamic Points-To Sets
IEEE Transactions on Software Engineering
An empirical study of static program slice size
ACM Transactions on Software Engineering and Methodology (TOSEM)
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Hi-index | 0.00 |
Understanding large software systems is difficult. Traditionally, automated tools are used to assist program understanding. However, the representations constructed by these tools often require prohibitive time and space. Demand-driven techniques can be used to reduce these requirements. However, the use of pointers in modern languages introduces additional problems that do not integrate well with these techniques. We present new techniques for effectively coping with pointers in large software systems written in the C programming language and use our techniques to implement a program slicing tool.First, we use a fast, flow-insensitive, points-to analysis before traditional data-flow analysis. Second, we allow the user to parameterize the points-to analysis so that the resulting program slices more closely match the actual program behavior. Such information cannot easily be obtained by the tool or might otherwise be deemed unsafe. Finally, we present data-flow equations for dealing with pointers to local variables in recursive programs. These equations allow the user to select an arbitrary amount of calling context in order to better trade performance for precision.To validate our techniques, we present empirical results using our program slicer on large programs. The results indicate that cost-effective analysis of large programs with pointers is feasible using our techniques.