Abstract interpretation is the name applied to a number of techniques for reasoning about programs by evaluating them over non-standard domains whose elements denote properties over the standard domains. This thesis is concerned with higherorder functional languages and abstract interpretations with a formal semantic basis. It is known how abstract interpretation for the simply typed lambda calculus can be formalised by using binary logical relations. This has the advantage of making correctness and other semantic concerns straightforward to reason about. Its main disadvantage is that it enforces the identification of properties as sets. This thesis shows how the known formalism can be generalised by the use of ternary logical relations, and in particular how this allows abstract values to deno...

interpretation [Abramsky and Hankin 1987; Cousot 1981; Jones and Nielson 1990] has been used to formulate a wide variety of static analyses aimed at optimizing programs in practical programming languages. Research in the area has been focusing on the conceptual and formal aspects of the topic. Special emphasis has been put on such issues as accuracy, termination, and relating non-standard and standard semantic definitions. However, the practical aspects involved in implementing an abstract interpreter have not received as much attention. This situation is even more pronounced for analyses of languages with higher-order functions. A static analysis includes a critical phase that consists of finding a fixpoint to a set of (possibly) recursive abstract functions derived from the analyzed program. To be of any practical use, an analysis should include an efficient and accurate fixpoint algorithm. The efficiency depends mostly on this accuracy. For example, some analyses only determine one ...

Lazy evaluation of functional programs incurs time and memory overheads, and restricts parallelism compared with programs that are evaluated strictly. A number of analysis techniques, such as abstract interpretation and projection analysis, have been developed to find out information that can alleviate these overheads. This paper formalises an evaluation model, the evaluation transformer model of reduction, which can use information from these analysis techniques, and proves that the resulting reduction strategies produce the same answers as those obtained using lazy evaluation.

A problem arises when the usual rules of fold/unfold transformation are applied in a non--strict programming system. Case analysis by instantiation may alter strictness characteristics of the function being transformed, and hence alter the behaviour of programs. Although such behavioural changes can in general be quite subtle, they are all too apparent if the program is interactive, since I/O interleaving is closely tied to strictness properties. A two--phase solution to the problem is proposed. It comprises a suitable form of strictness analysis to determine whether a proposed instantiation is safe, and a procedure to re--formulate troublesome definitions so that, in effect, case analysis is shifted to a nearby safe context. 1. Introduction We assume a purely functional programming language in the recursion equation style[7]. Data values are generated from constants and constructor functions. Functions other than constructors may be defined by cases in a series of clauses. In each ...

this paper, that results from this kind of analysis are, in a sense, polymorphic. This confirms an earlier conjecture [19], and shows how the technique can be applied to first-order polymorphic functions. The paper is organised as follows. In the next section, we review projection-based strictness analysis very briefly. In Section 3 we introduce the types we will be working with: they are the objects of a category. We show that parameterised types are functors, with certain cancellation properties. In Section 4 we define strong and weak polymorphism: polymorphic functions in programming languages are strongly polymorphic, but we will need to use projections with a slightly weaker property. We prove that, under certain conditions, weakly polymorphic functions are characterised by any non-trivial instance. We can therefore analyse one monomorphic instance of a polymorphic function using existing techniques, and apply the results to every instance. In Section 5 we choose a finite set of projections for each type, suitable for use in a practical compiler. We call these specially chosen projections contexts, and we show examples of factorising contexts for compound types in order to facilitate application of the results of Section 4. We give a number of examples of polymorphic strictness analysis. Finally, in Section 6 we discuss related work and draw some conclusions. 2. Projections for Strictness Analysis

This paper is an extension of a previous work where two non-determinism analyses were presented. The first of them was efficient (linear) but not very powerful and the second one was more powerful but very expensive (exponential). Here, we develop an intermediate analysis in both aspects, efficiency and power. The improvement in efficiency is obtained by speeding up the fixpoint calculation by means of a widening operator, and the representation of functions through easily comparable signatures. Also details about the implementation and its cost are given. Additionally: (1) the second and third analyses are completed with polymorphism, (2) we prove that the domains in the second and third analyses form a category in which the morphisms are embedding-closure pairs of functions; respectively called abstraction and concretisation functions; and (3) we formally relate the analyses and prove that the first analysis is a safe approximation to the third one and that the third one is a safe approximation to the second one. In this way the three analyses become totally ordered by increasing cost and precision. 1

We propose a syntactic approach to performing fixed point computation on finite domains. Finding fixed points in finite domains for monotonic functions is an essential task when calculating abstract semantics of functional programs. Previous methods for fixed point finding have been mainly based on semantic approaches which may be very inefficient even for simple programs. We outline the development of a syntactic approach, and show that the syntactic approach is sound and complete with respect to semantics. A few examples are provided to illustrate this syntactic approach. 1 Motivation and Introduction Finding fixed points for monotonic functions over finite domains is an important task in abstract interpretation. In abstract interpretation, a standard (or non--standard) semantics of a functional program is abstracted to a monotonic function over finite domains, and, if the program contains recursive definitions, fixed point finding is used to calculate the abstract semantics of th...

This paper proposes a model for studying the computation of fixpoints that arise in complex program analysis based on abstract interpretation, and presents an efficient algorithm for computing fixpoints based on the model. Abstract interpretation provides a unified framework for handling interprocedural analysis of programs with unrestricted pointer manipulation, higher-order functions, and continuations. In the general case, the structure of the fixpoint computation is not known before analysis; that is, the flow graph cannot be determined from the syntax of a program. Abstract interpretation handles this situation easily. In our algorithm, the entailment graph, representing the structure of the fixpoint computation, is developed during analysis. The strategies for determining the evaluation order, which underlie the algorithm, are described. Based on the strategies, local knowledge of the entailment graph at each node is exploited to determine dynamically an effective order of evalu...

Abstract. In the context of denotational style abstract interpretation it is crucial to have an efficient fixed point solver. In general, however, finding a fixed point requires exponential time. One approach to improving the efficiency is the use of special classes of functions. A well-known example for such a class are additive functions, which allow the reduction to quadratic runtime. In this paper, we demonstrate that additive functions are not suited in a higher-order context. To overcome this deficiency, we introduce the class of component-wise additive functions, which are an extension of the class of additive functions. Component-wise additive functions allow us to solve many higher-order equation systems in polynomial time. We stress the usefulness of our class by presenting a package for implementing abstract interpretations using our theoretical results. Furthermore, experimental results taken in a case study for escape analysis are presented to relate our approach to other approaches. 1

Non-determinism may affect the referential transparency of the programs written in Eden: If a nondeterministic expression is evaluated in different processes, the variable it is bound to it will denote possibly different values. It would be desirable to warn the programmer about this situation, or to force the evaluation of such an expression so that all the occurrences of the variable have the same value. Additionally there exist sequential transformations that are incorrect when non-determinism is involved. Such transformations should be applied only to those parts of the program that are sure to be deterministic. In this paper several analyses of different efficiency and power are presented. Several techniques are used: A types annotation system and abstract interpretation. 1 Introduction The parallel-functional language Eden extends the lazy functional language Haskell by syntactic constructs to explicitly define and communicate processes. The three main new concepts are process a...