Results 1  10
of
17
Interprocedural Slicing Using Dependence Graphs
 ACM TRANSACTIONS ON PROGRAMMING LANGUAGES AND SYSTEMS
, 1990
"... ... This paper concerns the problem of interprocedural slicinggenerating a slice of an entire program, where the slice crosses the boundaries of procedure calls. To solve this problem, we introduce a new kind of graph to represent programs, called a system dependence graph, which extends previou ..."
Abstract

Cited by 696 (78 self)
 Add to MetaCart
... This paper concerns the problem of interprocedural slicinggenerating a slice of an entire program, where the slice crosses the boundaries of procedure calls. To solve this problem, we introduce a new kind of graph to represent programs, called a system dependence graph, which extends previous dependence representations to incorporate collections of procedures (with procedure calls) rather than just monolithic programs. Our main result is an algorithm for interprocedural slicing that uses the new representation. (It should be noted that our work concerns a somewhat restricted kind of slice: Rather than permitting a program to be sliced with respect to program point p and an arbitrary variable, a slice must be taken with respect to a variable that is defined or used at p.) The chief
Solving ShapeAnalysis Problems in Languages with Destructive Updating
 POPL '96
, 1996
"... This paper concerns the static analysis of programs that perform destructive updating on heapallocated storage. We give an algorithm that conservatively solves this problem by using a finite shapegraph to approximate the possible “shapes” that heapallocated structures in a program can take on. In ..."
Abstract

Cited by 292 (19 self)
 Add to MetaCart
This paper concerns the static analysis of programs that perform destructive updating on heapallocated storage. We give an algorithm that conservatively solves this problem by using a finite shapegraph to approximate the possible “shapes” that heapallocated structures in a program can take on. In contrast with previous work, our method M even accurate for certain programs that update cyclic data structures. For example, our method can determine that when the input to a program that searches a list and splices in a new element is a possibly circular list, the output is a possibly circular list.
Pointer analysis: Haven’t we solved this problem yet?
 PASTE'01
, 2001
"... During the past twentyone years, over seventyfive papers and nine Ph.D. theses have been published on pointer analysis. Given the tomes of work on this topic one may wonder, "Haven't we solved this problem yet?" With input from many researchers in the field, this paper describes issues related to ..."
Abstract

Cited by 82 (1 self)
 Add to MetaCart
During the past twentyone years, over seventyfive papers and nine Ph.D. theses have been published on pointer analysis. Given the tomes of work on this topic one may wonder, "Haven't we solved this problem yet?" With input from many researchers in the field, this paper describes issues related to pointer analysis and remaining open problems.
Program specialization via program slicing
 Proceedings of the Dagstuhl Seminar on Partial Evaluation, volume 1110 of Lecture Notes in Computer Science
, 1996
"... This paper concerns the use of program slicing to perform a certain kind of programspecialization operation. The specialization operation that slicing performs is different from the specialization operations performed by algorithms for partial evaluation, supercompilation, bifurcation, and deforest ..."
Abstract

Cited by 55 (4 self)
 Add to MetaCart
This paper concerns the use of program slicing to perform a certain kind of programspecialization operation. The specialization operation that slicing performs is different from the specialization operations performed by algorithms for partial evaluation, supercompilation, bifurcation, and deforestation. In particular, we present an example in which the specialized program that we create via slicing could not be created as the result of applying partial evaluation, supercompilation, bifurcation, or deforestation to the original unspecialized program. Specialization via slicing also possesses an interesting property that partial evaluation, supercompilation, and bifurcation do not possess: The latter operations are somewhat limited in the sense that they support tailoring of existing software only according to the ways in which parameters of functions and procedures are used in a program. Because parameters to functions and procedures represent the range of usage patterns that the designer of a piece of software has anticipated, partial evaluation, supercompilation, and bifurcation support specialization only in ways that have already been “foreseen ” by the software’s author. In contrast, the specialization operation that slicing supports permits programs to be specialized in ways
Is it a Tree, a DAG, or a Cyclic Graph?
, 1996
"... This paper reports on the design and implementation of a practical shape analysis for C. The purpose of the analysis is to aid in the disambiguation of heapallocated data structures by estimating the shape (Tree, DAG, or Cyclic Graph) of the data structure accessible from each heapdirected pointer ..."
Abstract

Cited by 37 (0 self)
 Add to MetaCart
This paper reports on the design and implementation of a practical shape analysis for C. The purpose of the analysis is to aid in the disambiguation of heapallocated data structures by estimating the shape (Tree, DAG, or Cyclic Graph) of the data structure accessible from each heapdirected pointer. This shape information can be used to improve dependence testing and in parallelization, and to guide the choice of more complex heap analyses. The method has been implemented as a contextsensitive interprocedural analysis in the McCAT compiler. Experimental results and observations are given for 16 benchmark programs. These results show that the analysis gives accurate and useful results for an important group of applications. 1 Introduction and Related Work Pointer analyses are of critical importance for optimizing /parallelizing compilers that support languages like C, C++ and FORTRAN90. The pointer analysis problem can be divided into two distinct subproblems: (i) analyzing pointers t...
Interconvertibility of Set Constraints and ContextFree Language Reachability
 In Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and SemanticsBased Program Manipulation
, 1996
"... We show the interconvertibility of contextfreelanguage reachability problems and a class of setconstraint problems: given a contextfreelanguage reachability problem, we show how to construct a setconstraint problem whose answer gives a solution to the reachability problem; given a setconstrai ..."
Abstract

Cited by 29 (1 self)
 Add to MetaCart
We show the interconvertibility of contextfreelanguage reachability problems and a class of setconstraint problems: given a contextfreelanguage reachability problem, we show how to construct a setconstraint problem whose answer gives a solution to the reachability problem; given a setconstraint problem, we show how to construct a contextfreelanguage reachability problem whose answer gives a solution to the setconstraint problem. The interconvertibility of these two formalisms offers an conceptual advantage akin to the advantage gained from the interconvertibility of finitestate automata and regular expressions in formal language theory, namely, a problem can be formulated in whichever formalism is most natural. It also offers some insight into the "O(n³) bottleneck" for different types of programanalysis problems, and allows results previously obtained for contextfreelanguage reachability problems to be applied to setconstraint problems.
The set constraint/cfl reachability connection in practice
, 2004
"... Many program analyses can be reduced to graph reachability problems involving a limited form of contextfree language reachability called DyckCFL reachability. We show a new reduction from DyckCFL reachability to set constraints that can be used in practice to solve these problems. Our reduction i ..."
Abstract

Cited by 29 (3 self)
 Add to MetaCart
Many program analyses can be reduced to graph reachability problems involving a limited form of contextfree language reachability called DyckCFL reachability. We show a new reduction from DyckCFL reachability to set constraints that can be used in practice to solve these problems. Our reduction is much simpler than the general reduction from contextfree language reachability to set constraints. We have implemented our reduction on top of a set constraints toolkit and tested its performance on a substantial polymorphic flow analysis application.
Interconvertibility of a Class of Set Constraints and ContextFreeLanguage Reachability
 TCS
, 1998
"... We show the interconvertibility of contextfreelanguage reachability problems and a class of setconstraint problems: given a contextfreelanguage reachability problem, we show how to construct a setconstraint problem whose answer gives a solution to the reachability problem; given a setconstra ..."
Abstract

Cited by 27 (2 self)
 Add to MetaCart
We show the interconvertibility of contextfreelanguage reachability problems and a class of setconstraint problems: given a contextfreelanguage reachability problem, we show how to construct a setconstraint problem whose answer gives a solution to the reachability problem; given a setconstraint problem, we show how to construct a contextfreelanguage reachability problem whose answer gives a solution to the setconstraint problem. The interconvertibility of these two formalisms offers an conceptual advantage akin to the advantage gained from the interconvertibility of finitestate automata and regular expressions in formal language theory, namely, a problem can be formulated in whichever formalism is most natural. It also offers some insight into the "O(n ) bottleneck" for different types of programanalysis problems and allows results previously obtained for contextfreelanguage reachability problems to be applied to setconstraint problems and vice versa.
Undecidability of Contextsensitive Datadependence Analysis
 Transactions on Programming Languages and Systems
, 1999
"... Anumber of programanalysis problems can be tackled by transforming them into certain kinds of graphreachability problems in labeled directed graphs. The edge labels can be used to filter out paths that are not of interest: A path P from vertex s to vertex t only counts as a “valid connection ” bet ..."
Abstract

Cited by 14 (2 self)
 Add to MetaCart
Anumber of programanalysis problems can be tackled by transforming them into certain kinds of graphreachability problems in labeled directed graphs. The edge labels can be used to filter out paths that are not of interest: A path P from vertex s to vertex t only counts as a “valid connection ” between s and t if the word spelled out by P is in a certain language. Often the languages used for such filtering purposes are languages of matching parentheses: • Insome cases, the matchedparenthesis condition is used to filter out paths with mismatched calls and returns. This leads to socalled “contextsensitive ” program analyses, such as contextsensitive interprocedural slicing and contextsensitive interprocedural dataflow analysis. • Inother cases, the matchedparenthesis condition is used to capture a graphtheoretic analog of McCarthy’s rules: “car(cons(x,y))=x ” and “cdr(cons(x,y))=y”. That is, in the code fragment c=cons(a,b); d=car(c); the fact that there is a “structuretransmitted data dependence ” from a to d, but not from b to d, iscaptured in a graph by using (i) avertex for each variable, (ii) an edge from vertex i to vertex j when i is used on the righthand side of an assignment to j, (iii) parentheses that match as the labels on the edges that run fromatocandctod, and (iv) parentheses that do not match as the labels on the edges that run frombtocandctod.
Detecting InefficientlyUsed Containers to Avoid Bloat
 ACM SIGPLAN 2010 CONFERENCE ON PROGRAMMING LANGUAGE DESIGN AND IMPLEMENTATION
, 2010
"... Runtime bloat degrades significantly the performance and scalability of software systems. An important source of bloat is the inefficient use of containers. It is expensive to create inefficientlyused containers and to invoke their associated methods, as this may ultimately execute large volumes of ..."
Abstract

Cited by 8 (4 self)
 Add to MetaCart
Runtime bloat degrades significantly the performance and scalability of software systems. An important source of bloat is the inefficient use of containers. It is expensive to create inefficientlyused containers and to invoke their associated methods, as this may ultimately execute large volumes of code, with call stacks dozens deep, and allocate many temporary objects. This paper presents practical static and dynamic tools that can find inappropriate use of containers in Java programs. At the core of these tools is a base static analysis that identifies, for each container, the objects that are added to this container and the key statements (i.e., heap loads and stores) that achieve the semantics of common container operations such as ADD and GET. The static tool finds problematic uses of containers by considering the nesting relationships among the loops where these semanticsachieving statements