Results 1  10
of
351
A Survey of Program Slicing Techniques
 JOURNAL OF PROGRAMMING LANGUAGES
, 1995
"... A program slice consists of the parts of a program that (potentially) affect the values computed at some point of interest, referred to as a slicing criterion. The task of computing program slices is called program slicing. The original definition of a program slice was presented by Weiser in 197 ..."
Abstract

Cited by 790 (10 self)
 Add to MetaCart
A program slice consists of the parts of a program that (potentially) affect the values computed at some point of interest, referred to as a slicing criterion. The task of computing program slices is called program slicing. The original definition of a program slice was presented by Weiser in 1979. Since then, various slightly different notions of program slices have been proposed, as well as a number of methods to compute them. An important distinction is that between a static and a dynamic slice. The former notion is computed without making assumptions regarding a program's input, whereas the latter relies on some specific test case. Procedures, arbitrary control flow, composite datatypes and pointers, and interprocess communication each require a specific solution. We classify static and dynamic slicing methods for each of these features, and compare their accuracy and efficiency. Moreover, the possibilities for combining solutions for different features are investigated....
Dynamically discovering likely program invariants to support program evolution.
 ICSE
, 1999
"... ..."
(Show Context)
Pointsto Analysis in Almost Linear Time
, 1996
"... We present an interprocedural flowinsensitive pointsto analysis based on type inference methods with an almost linear time cost complexity. To our knowledge, this is the asymptotically fastest nontrivial interprocedural pointsto analysis algorithm yet described. The algorithm is based on a nons ..."
Abstract

Cited by 595 (3 self)
 Add to MetaCart
We present an interprocedural flowinsensitive pointsto analysis based on type inference methods with an almost linear time cost complexity. To our knowledge, this is the asymptotically fastest nontrivial interprocedural pointsto analysis algorithm yet described. The algorithm is based on a nonstandard type system. The type inferred for any variable represents a set of locations and includes a type which in turn represents a set of locations possibly pointed to by the variable. The type inferred for a function variable represents a set of functions it may point to and includes a type signature for these functions. The results are equivalent to those of a flowinsensitive alias analysis (and control flow analysis) that assumes alias relations are reflexive and transitive. This work makes
Efficient ContextSensitive Pointer Analysis for C Programs
, 1995
"... This paper proposes an efficient technique for contextsensitive pointer analysis that is applicable to real C programs. For efficiency, we summarize the effects of procedures using partial transfer functions. A partial transfer function (PTF) describes the behavior of a procedure assuming that certa ..."
Abstract

Cited by 433 (7 self)
 Add to MetaCart
(Show Context)
This paper proposes an efficient technique for contextsensitive pointer analysis that is applicable to real C programs. For efficiency, we summarize the effects of procedures using partial transfer functions. A partial transfer function (PTF) describes the behavior of a procedure assuming that certain alias relationships hold when it is called. We can reuse a PTF in many calling contexts as long as the aliases among the inputs to the procedure are the same. Our empirical results demonstrate that this technique is successfula single PTF per procedure is usually sufficient to obtain completely contextsensitive results. Because many C programs use features such as type casts and pointer arithmetic to circumvent the highlevel type system, our algorithm is based on a lowlevel representation of memory locations that safely handles all the features of C. We have implemented our algorithm in the SUIF compiler system and we show that it runs efficiently for a set of C benchmarks. 1 Introd...
Compositional Pointer and Escape Analysis for Java Programs
 In Proceedings of the 14th Annual Conference on ObjectOriented Programming Systems, Languages and Applications
, 1999
"... algorithm for Java programs. The algorithm is based on the abstraction of pointsto escape graphs, which characterize how local variables and elds in objects refer to other objects. Each pointsto escape graph also contains escape information, which characterizes how objects allocated in one region ..."
Abstract

Cited by 267 (29 self)
 Add to MetaCart
(Show Context)
algorithm for Java programs. The algorithm is based on the abstraction of pointsto escape graphs, which characterize how local variables and elds in objects refer to other objects. Each pointsto escape graph also contains escape information, which characterizes how objects allocated in one region of the program can escape to be accessed by another region. The algorithm is designed to analyze arbitrary regions of complete or incomplete programs, obtaining complete information for objects that do not escape the analyzed regions.
Efficient FlowSensitive Interprocedural Computation of PointerInduced Aliases and Side Effects
, 1993
"... We present practical approximation methods for computing interprocedural aliases and side effects for a program written in a language that includes pointers, reference parameters and recursion. We present the following results: 1) An algorithm for flowsensitive interprocedural alias analysis which ..."
Abstract

Cited by 231 (11 self)
 Add to MetaCart
(Show Context)
We present practical approximation methods for computing interprocedural aliases and side effects for a program written in a language that includes pointers, reference parameters and recursion. We present the following results: 1) An algorithm for flowsensitive interprocedural alias analysis which is more precise and efficient than the best interprocedural method known. 2) An extension of traditional flowinsensitive alias analysis which accommodates pointers and provides a framework for a family of algorithms which trade off precision for efficiency. 3) An algorithm which correctly computes side effects in the presence of pointers. Pointers cannot be correctly handled by conventional methods for side effect analysis. 4) An alias naming technique which handles dynamically allocated objects and guarantees the correctness of dataflow analysis. 5) A compact representation based on transitive reduction which does not result in a loss of precision and improves precision in some cases. 6)...
Unificationbased Pointer Analysis with Directional Assignments
, 2000
"... This paper describes a new algorithm for flow and context insensitive pointer analysis of C programs. Our studies show that the most common use of pointers in C programs is in passing the addresses of composite objects or updateable values as arguments to procedures. Therefore, we have designed a lo ..."
Abstract

Cited by 217 (7 self)
 Add to MetaCart
This paper describes a new algorithm for flow and context insensitive pointer analysis of C programs. Our studies show that the most common use of pointers in C programs is in passing the addresses of composite objects or updateable values as arguments to procedures. Therefore, we have designed a lowcost algorithm that handles this common case accurately. In terms of both precision and running time, this algorithm lies between Steensgaard's algorithm, which treats assignments bidirectionally using unification, and Andersen's algorithm, which treats assignments directionally using subtyping. Our "one level flow" algorithm uses a restricted form of subtyping to avoid unification of symbols at the top levels of pointer chains in the pointsto graph, while using unification elsewhere in the graph. The method scales easily to large programs. For instance, we are able to analyze a 1.4 MLOC (million lines of code) program in two minutes, using less than 200MB of memory. At the same time, the pr...
Pointer Analysis for Multithreaded Programs
 ACM SIGPLAN 99
, 1999
"... This paper presents a novel interprocedural, flowsensitive, and contextsensitive pointer analysis algorithm for multithreaded programs that may concurrently update shared pointers. For each pointer and each program point, the algorithm computes a conservative approximation of the memory locations ..."
Abstract

Cited by 163 (12 self)
 Add to MetaCart
This paper presents a novel interprocedural, flowsensitive, and contextsensitive pointer analysis algorithm for multithreaded programs that may concurrently update shared pointers. For each pointer and each program point, the algorithm computes a conservative approximation of the memory locations to which that pointer may point. The algorithm correctly handles a full range of constructs in multithreaded programs, including recursive functions, function pointers, structures, arrays, nested structures and arrays, pointer arithmetic, casts between pointer variables of different types, heap and stack allocated memory, shared global variables, and threadprivate global variables. We have implemented the algorithm in the SUIF compiler system and used the implementation to analyze a sizable set of multithreaded programs written in the Cilk multithreaded programming language. Our experimental results show that the analysis has good precision and converges quickly for our set of Cilk programs.
Fast and Accurate FlowInsensitive PointsTo Analysis
 IN SYMPOSIUM ON PRINCIPLES OF PROGRAMMING LANGUAGES
, 1997
"... In order to analyze a program that involves pointers, it is necessary to have (safe) information about what each pointer points to. There are many different approaches to computing pointsto information. This paper addresses techniques for flow and contextinsensitive interprocedural analysis of st ..."
Abstract

Cited by 162 (3 self)
 Add to MetaCart
In order to analyze a program that involves pointers, it is necessary to have (safe) information about what each pointer points to. There are many different approaches to computing pointsto information. This paper addresses techniques for flow and contextinsensitive interprocedural analysis of stackbased storage. The paper makes two contributions to work in this area: ffl The first contribution is a set of experiments that explore the tradeoffs between techniques previously defined by Lars Andersen and Bjarne Steensgaard. The former has a cubic worstcase running time, while the latter is essentially linear. However, the former may be much more precise than the latter. We have found that in practice, Andersen's algorithm is consistently more precise than Steensgaard's. For small programs, there is very little difference in the times required by the two approaches; however, for larger programs, Andersen's algorithm can be much slower than Steensgaard's. ffl The second contrib...
A Schema for Interprocedural Modification SideEffect Analysis With Pointer Aliasing
, 2001
"... The first interprocedural modification sideeffects analysis for C (MODC) that obtains better than worstcase precision on programs with generalpurpose pointer usage is presented with empirical results. The analysis consists of an algorithm schema corresponding to a family of MODC algorithms with t ..."
Abstract

Cited by 139 (12 self)
 Add to MetaCart
The first interprocedural modification sideeffects analysis for C (MODC) that obtains better than worstcase precision on programs with generalpurpose pointer usage is presented with empirical results. The analysis consists of an algorithm schema corresponding to a family of MODC algorithms with two independent phases: one for determining pointerinduced aliases and a subsequent one for propagating interprocedural side effects. These MODC algorithms are parameterized by the aliasing method used. The empirical results compare the performance of two dissimilar MODC algorithms: MODC(FSAlias) uses a flowsensitive, callingcontextsensitive interprocedural alias analysis; MODC(FIAlias) uses a flowinsensitive, callingcontextinsensitive alias analysis which is much faster, but less accurate. These two algorithms were profiled on 45 programs ranging in size from 250 to 30,000 lines of C code, and the results demonstrate dramatically the possible costprecision tradeoffs. This first comparative implementation of MODC analyses offers insight into the differences between flow/contextsensitive and flow/contextinsensitive analyses. The analysis cost versus precision tradeoffs in sideeffect information obtained are reported. The results show surprisingly that the precision of flowsensitive sideeffect analysis is not always prohibitive in cost, and that the precision of flowinsensitive analysis is substantially better than worstcase estimates