Results 1  10
of
14
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 518 (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
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 149 (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...
Efficient Type Inference for HigherOrder BindingTime Analysis
 In Functional Programming and Computer Architecture
, 1991
"... Bindingtime analysis determines when variables and expressions in a program can be bound to their values, distinguishing between early (compiletime) and late (runtime) binding. Bindingtime information can be used by compilers to produce more efficient target programs by partially evaluating prog ..."
Abstract

Cited by 91 (4 self)
 Add to MetaCart
Bindingtime analysis determines when variables and expressions in a program can be bound to their values, distinguishing between early (compiletime) and late (runtime) binding. Bindingtime information can be used by compilers to produce more efficient target programs by partially evaluating programs at compiletime. Bindingtime analysis has been formulated in abstract interpretation contexts and more recently in a typetheoretic setting. In a typetheoretic setting bindingtime analysis is a type inference problem: the problem of inferring a completion of a λterm e with bindingtime annotations such that e satisfies the typing rules. Nielson and Nielson and Schmidt have shown that every simply typed λterm has a unique completion ê that minimizes late binding in TML, a monomorphic type system with explicit bindingtime annotations, and they present exponential time algorithms for computing such minimal completions. 1 Gomard proves the same results for a variant of his twolevel λcalculus without a socalled “lifting ” rule. He presents another algorithm for inferring completions in this somewhat restricted type system and states that it can be implemented in time O(n 3). He conjectures that the completions computed are minimal.
The Effects of the Precision of Pointer Analysis
 In Proceedings of the 4th International Symposium on Static Analysis
, 1997
"... . In order to analyze programs that manipulate pointers, it is necessary to have safe information about what each pointer might point to. There are many algorithms that can be used to determine this information, with varying degrees of accuracy. However, there has been very little previous work that ..."
Abstract

Cited by 75 (1 self)
 Add to MetaCart
. In order to analyze programs that manipulate pointers, it is necessary to have safe information about what each pointer might point to. There are many algorithms that can be used to determine this information, with varying degrees of accuracy. However, there has been very little previous work that addresses how much the relative accuracies of different pointeranalysis algorithms affect "transitive" results: the results of a subsequent analysis. We have carried out a number of experiments with flowinsensitive, contextinsensitive pointer analyses to address the following questions:  How are the transitive effects of pointer analysis affected by the precision of the analysis?  How good are the "direct" effects of pointer analysis (the sizes of the computed pointsto sets) at predicting the transitive effects?  What are the time tradeoffs? We found that using a more precise pointer analysis does in general lead to more precise transitive results. However, the magnitude of th...
Global Tagging Optimization by Type Inference
 Proc. 1992 ACM Symposium on Lisp and Functional Programming
"... Tag handling accounts for a substantial amount of execution cost in latently typed languages such as Common LISP and Scheme, especially on architectures that provide no special hardware support. We present a tagging optimization algorithm based on type inference that is global: it traces tag informa ..."
Abstract

Cited by 50 (1 self)
 Add to MetaCart
Tag handling accounts for a substantial amount of execution cost in latently typed languages such as Common LISP and Scheme, especially on architectures that provide no special hardware support. We present a tagging optimization algorithm based on type inference that is global: it traces tag information across procedure boundaries, not only within procedures; efficient: it runs asymptotically in almostlinear time with excellent practical runtime behavior (e.g. 5,000 line Scheme programs are processed in a matter of seconds); useful: it eliminates at compiletime between 60 and 95 % of tag handling operations in nonnumerical Scheme code (based on preliminary data); structural: it traces tag information in higher order (procedure) values and especially in structured (e.g. list) values, where reportedly 80 % of tag handling operations take place; wellfounded: it is based on a formal static typing discpline with a special type Dynamic that has a robust and semantically sound “minimal typing ” property; implementationindependent: no tag implementation technology is presupposed; the results are displayed as an explicitly typed source program and can be interfaced with compiler backends of statically typed languages such as Standard ML; userfriendly: no annotations by the programmer are necessary; it operates on the program source, provides useful type information to a programmer in the spirit of ML’s type system, and makes all tag handling operations necessary at runtime explicit (and thus shows which ones can be eliminated without endangering correctness of program execution). This agenda is accomplished by: • maintaining and tracing only a minimum of information — no sets of abstract closures or cons points etc. that may reach a program point are kept, only their collective tagging information; no repeated analysis of program points is performed;
Dynamic Typing
 In Proc. Fourth European Symp. Programming (ESOP’92
, 1992
"... We present an extension of a statically typed language with a special type Dynamic and explicit type tagging and checking operations (coercions). Programs in runtime typed languages are viewed as incomplete programs that are to be completed to welltyped programs by explicitly inserting coercions i ..."
Abstract

Cited by 36 (3 self)
 Add to MetaCart
We present an extension of a statically typed language with a special type Dynamic and explicit type tagging and checking operations (coercions). Programs in runtime typed languages are viewed as incomplete programs that are to be completed to welltyped programs by explicitly inserting coercions into them. Such completions are generally not unique. If the meaning of an incomplete program is to be the meaning of any of its completions and if it is too be unambiguous it is necessary that all its completions are coherent (semantically equivalent). We characterize with an equational theory the properties a semantics must satisfy to be coherent. Since “naive ” coercion evaluation does not satisfy all of the coherence equations we exclude certain “unsafe ” completions from consideration that can cause avoidable type errors at runtime. Various classes of completions may be used, parameterized by whether or not coercions may only occur at data creation and data use points in a program and whether only primitive coercions or also induced coercions. For each of these classes any term has a minimal completion that is optimal in the sense that it contains no coercions that could be avoided by a another coercion in the same class. In particular, minimal completions contain no coercions at all whenever the program is statically typable. If only primitive type operations are admitted we show that minimal completions can be computed in almostlinear time. If induced coercions are also allowed the minimal completion can be computed in time O(nm) where n is the size of the program and m is the size of the value flow graph of the program, which may be of size O(n 2), but is typically rather sparse. Finally, we sketch how this explicit dynamic typing discipline can be extended to letpolymorphism by parameterization with respect to coercions. The resulting language framework leads to a seamless integration of statically typed and dynamically typed languages by relying on type inference for programs that have no type information and no explicit coercions whatsoever. 1
BindingTime Analysis and the Taming of C Pointers
 In Partial Evaluation and SemanticsBased Program Manipulation
, 1993
"... The aim of bindingtime analysis is to determine when variables, expressions, statements, etc. in a program can be evaluated by classifying these into static (compiletime) and dyamic (runtime). Explicit separation of binding times has turned out to be crucial for successful selfapplication of par ..."
Abstract

Cited by 29 (1 self)
 Add to MetaCart
The aim of bindingtime analysis is to determine when variables, expressions, statements, etc. in a program can be evaluated by classifying these into static (compiletime) and dyamic (runtime). Explicit separation of binding times has turned out to be crucial for successful selfapplication of partial evaluators, and apparently, it is also an important steppingstone for profitable specialization of imperative languages with pointers and dynamic memory allocation. In this paper we present an automatic bindingtime analysis for a substantial subset of the C language. The paper has two parts. In the first part, the semantic issues of bindingtime separation is discussed with emphasis on pointers and classification of these. This leads to the introduction of a twolevel C language where binding times are explicit in the syntax. Finally, wellannotatedness rules are given which excludes nonconsistently annotated programs. In the second part, an automatic bindingtime analysis based on c...
Type inference and semiunification
 In Proceedings of the ACM Conference on LISP and Functional Programming (LFP ) (Snowbird
, 1988
"... In the last ten years declarationfree programming languages with a polymorphic typing discipline (ML, B) have been developed to approximate the flexibility and conciseness of dynamically typed languages (LISP, SETL) while retaining the safety and execution efficiency of conventional statically type ..."
Abstract

Cited by 25 (6 self)
 Add to MetaCart
In the last ten years declarationfree programming languages with a polymorphic typing discipline (ML, B) have been developed to approximate the flexibility and conciseness of dynamically typed languages (LISP, SETL) while retaining the safety and execution efficiency of conventional statically typed languages (Algol68, Pascal). These polymorphic languages can be type checked at compile time, yet allow functions whose arguments range over a variety of types. We investigate several polymorphic type systems, the most powerful of which, termed MilnerMycroft Calculus, extends the socalled letpolymorphism found in, e.g., ML with a polymorphic typing rule for recursive definitions. We show that semiunification, the problem of solving inequalities over firstorder terms, characterizes type checking in the MilnerMycroft Calculus to polynomial time, even in the restricted case where nested definitions are disallowed. This permits us to extend some infeasibility results for related combinatorial problems to type inference and to correct several claims and statements in the literature. We prove the existence of unique most general solutions of term inequalities, called most general semiunifiers, and present an algorithm for computing them that terminates for all known inputs due to a novel “extended occurs check”. We conjecture this algorithm to be
Fast BindingTime Analysis for MultiLevel Specialization
 PERSPECTIVES OF SYSTEM INFORMATICS. PROCEEDINGS, VOLUME 1181 OF LECTURE NOTES IN COMPUTER SCIENCE
, 1996
"... Program specialization can divide a computation into several computation stages. We present the key ingredient of our approach to multilevel specialization: an accurate and fast multilevel bindingtime analysis. Three e#cient program analyses for higherorder, functional languages are presente ..."
Abstract

Cited by 21 (3 self)
 Add to MetaCart
Program specialization can divide a computation into several computation stages. We present the key ingredient of our approach to multilevel specialization: an accurate and fast multilevel bindingtime analysis. Three e#cient program analyses for higherorder, functional languages are presented which are based on constraint systems and run almostlinear in the size of the analyzed programs. The three constraint normalizations have been proven correct (soundness, completeness, termination, existence of best solution). The analyses have all been implemented for a substantial, higherorder subset of Scheme. Experiments with widelyavailable example programs confirm the excellent runtime behavior of the normalization algorithms.
Evaluating the Effectiveness of Pointer Alias Analyses
 SCIENCE OF COMPUTER PROGRAMMING
, 1999
"... This paper describes an empirical comparison of the effectiveness of six contextinsensitive pointer analysis algorithms that use varying degrees of flowsensitivity. Four of the algorithms are flowinsensitive, one is flowsensitive, and another is flowinsensitive, but uses precomputed flowsens ..."
Abstract

Cited by 19 (1 self)
 Add to MetaCart
This paper describes an empirical comparison of the effectiveness of six contextinsensitive pointer analysis algorithms that use varying degrees of flowsensitivity. Four of the algorithms are flowinsensitive, one is flowsensitive, and another is flowinsensitive, but uses precomputed flowsensitive information. The effectiveness of each analysis is quantified in terms of compiletime efficiency and precision. Efficiency is reported by measuring CPU time and memory consumption of each analysis. Precision is reported by measuring the computed solutions at the program points where a pointer is dereferenced. The results of this paper will help implementors determine which pointer analysis is appropriate for their application.