Results 1  10
of
132
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 553 (2 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 411 (9 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 245 (28 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.
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 142 (13 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.
A Schema for Interprocedural Modification SideEffect Analysis With Pointer Aliasing
 In Proceedings of the SIGPLAN '93 Conference on Programming Language Design and Implementation
, 2001
"... The first interprocedural modification sideeffects analysis for C (MOD_C) 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 ..."
Abstract

Cited by 134 (13 self)
 Add to MetaCart
The first interprocedural modification sideeffects analysis for C (MOD_C) 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 MOD_C algorithms are parameterized by the aliasing method used. The empirical results compare the performance of two dissimilar MOD_C algorithms: MOD_C(FSAlias) uses a flowsensitive, callingcontextsensitive interprocedural alias analysis [LR92]; MOD_C(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 is 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 and seems sufficient for certain applications. On average MODC (FSAlias) for procedures and calls is in the range of 20% more precise than MODC (F IAlias); however, the performance was found to be at least an order of magnitude slower than MODC (F IAlias).
Relevant Context Inference
, 1999
"... Relevant context inference (RCI) is a modular technique for flow and contextsensitive dataflow analysis of statically typed objectoriented programming languages such as C ++ and Java. RCI can be used to analyze complete programs as well as incomplete programs such as libraries; this approach do ..."
Abstract

Cited by 112 (19 self)
 Add to MetaCart
Relevant context inference (RCI) is a modular technique for flow and contextsensitive dataflow analysis of statically typed objectoriented programming languages such as C ++ and Java. RCI can be used to analyze complete programs as well as incomplete programs such as libraries; this approach does not require that the entire program be memoryresident during the analysis. RCI is presented in the context of pointsto analysis for a realistic subset of C ++ . The empirical evidence obtained from a prototype implementation argues the effectiveness of RCI. 1 Introduction Pointsto analysis [EGH94] for statically typed objectoriented programming languages (e.g., Java, C ++ ) determines, at each program point, the objects to which a pointer may point during execution. This information is crucial to many applications, including static resolution of dynamically dispatched calls, sideeffect analysis, dataflowbased testing, program slicing and aggressive compiler optimizations. The s...
Interprocedural Pointer Alias Analysis
 ACM Transactions on Programming Languages and Systems
, 1999
"... this article, we describe approximation methods for computing interprocedural aliases for a program written in a language that includes pointers, reference parameters, and recursion. We present the following contributions: ..."
Abstract

Cited by 107 (8 self)
 Add to MetaCart
(Show Context)
this article, we describe approximation methods for computing interprocedural aliases for a program written in a language that includes pointers, reference parameters, and recursion. We present the following contributions:
Modular Interprocedural Pointer Analysis Using Access Paths: Design, Implementation, and Evaluation
, 2000
"... In this paper we present a modular interprocedural pointer analysis algorithm based on accesspaths for C programs. We argue that access paths can reduce the overhead of representing contextsensitive transfer functions and effectively distinguish nonrecursive heap objects. And when the modular ana ..."
Abstract

Cited by 102 (6 self)
 Add to MetaCart
In this paper we present a modular interprocedural pointer analysis algorithm based on accesspaths for C programs. We argue that access paths can reduce the overhead of representing contextsensitive transfer functions and effectively distinguish nonrecursive heap objects. And when the modular analysis paradigm is used together with other techniques to handle type casts and function pointers, we are able to handle significant programs like those in the SPECcint92 and SPECcint95 suites. We have implemented the algorithm and tested it on a Pentium II 450 PC running Linux. The observed resource consumption and performance improvement are very encouraging.
Typebased alias analysis
 In Proceedings of the ACM SIGPLAN '98 Conference on Programming Language Design and Implementation
, 1998
"... This paper evaluates three alias analyses based on programming language types. The first analysis uses type compatibility to determine aliases. The second extends the first by using additional highlevel information such as field names. The third extends the second with a flowinsensitive analysi ..."
Abstract

Cited by 98 (5 self)
 Add to MetaCart
(Show Context)
This paper evaluates three alias analyses based on programming language types. The first analysis uses type compatibility to determine aliases. The second extends the first by using additional highlevel information such as field names. The third extends the second with a flowinsensitive analysis. Although other researchers suggests using types to disambiguate memory references, none evaluates its effectiveness. We perform both static and dynamic evaluations of typebased alias analyses for Modula3, a staticallytyped typesafe language. The static analysis reveals that type compatibility alone yields a very imprecise alias analysis, but the other two analyses significantly improve alias precision. We use redundant load elimination (RLE) to demonstrate the effectiveness of the three alias algorithms in terms of the opportunities for optimization, the impact on simulated execution times, and to compute an upper bound on what a perfect alias analysis would yield. We show modest dynamic improvements for (RLE), and more surprisingly, that on average our alias analysis is within 2.5 % of a perfect alias analysis with respect to RLE on 8 Modula3 programs. These results illustrate that to explore thoroughly the effectiveness of alias analyses, researchers need static, dynamic, and upperbound analysis. In addition, we show that for typesafe languages like Modula3 and Java, a fast and simple alias analysis may be sufficient for many applications. 1