Analysis
We Static often want to automatically discover certain properties of a program. A particular application is for optimising transformations in a compiler. Since the aim is to analyse the program without running it (i.e. statically) we call the process static analysis.
Abstract Interpretation
For Static Analysis
Abstract Interpretation
Abstract interpretation is a semantics-based technique that can be used to derive useful information about a program. It is one of the most common frameworks for static analysis.
Comp3610 Principles of Programming Languages Australian National University Semester 2, 2007 Clem Baker-Finch
This lecture is about the general concept of abstract interpretation. The next lecture is about a particular application of abstract interpretation to perform strictness analysis of lazy functional programs.
COMP 3610 Abstract interpreters
1
COMP 3610 Abstract interpreters
2
Puzzle:
What is the sign of x? x = 1432 (33) (87) Is x even? We dont need to calculate the value of x to know that it is positive and even. This is the essence of abstract interpretation rather than the values themselves, we work with abstract values: 1432 (33) (87) becomes: pos neg neg
Another puzzle:
What is the sign of these expressions? a = 122 + 57 b = 1028 + (1234) c = 1432 + (33) 44 We cant always tell the sign without extra information, or actually doing the calculation: The rules of signs are partial. The idea of abstract interpretation is to only work with the abstract values. In this case, the only information we have is the sign of subexpressions. Therefore, abstract interpreters are often partial. They may only give an approximation to the true abstract value.
The operator is dened on the domain of abstract values, e.g.: pos neg = neg neg neg = pos etc . . .
COMP 3610 Abstract interpreters
3
COMP 3610 Abstract interpreters
4
Standard interpreter for arithmetic expressions:
(Begin example Sign2.lhs) data Exp = Num Int | Mul Exp Exp | Add Exp Exp interpret :: interpret (Num n) = interpret (Mul e1 e2) = interpret (Add e1 e2) = Exp -> Int n interpret e1 * interpret e2 interpret e1 + interpret e2
Abstract domain of signs:
data Sign = Pos | Neg | Zero | DontKnow deriving Show signInt signInt | n | n | n :: Int -> Sign n > 0 = Pos < 0 = Neg == 0 = Zero
COMP 3610 Abstract interpreters
5
COMP 3610 Abstract interpreters
6
Abstract interpreter:
(for inferring signs of arithmetic expressions)
The abstract operators:
(*#) :: Sign -> Sign -> Sign Neg Neg Neg Neg *# *# *# *# DontKnow Zero Pos Neg = = = = DontKnow Zero Neg Pos
signInterp :: signInterp (Num n) = signInterp (Mul e1 e2) = signInterp (Add e1 e2) =
Exp -> Sign signInt n signInterp e1 *# signInterp e2 signInterp e1 +# signInterp e2
Pos *# sign Note that it is identical to the standard interpreter, except that the standard operators + and have been replaced by abstract operators, + and + . and operate on the standard domain of integers. + and operate on the abstract domain of signs. Zero *# _
= sign = Zero
DontKnow *# Zero = Zero DontKNow *# _ = DontKnow
COMP 3610 Abstract interpreters
7
COMP 3610 Abstract interpreters
8
(+#) :: Sign -> Sign -> Sign Pos +# DontKnow Pos +# Neg Pos +# _ Neg +# DontKnow Neg +# Pos Neg +# _ = DontKnow = DontKnow = Pos = DontKnow = DontKnow = Neg
Abstract Interpretation
It is common to represent the abstraction (e.g. from integers to signs) as a commuting triangle:
f S D
f#
abs
Zero +# DontKnow = DontKnow Zero +# sign = sign DontKnow +# _ = DontKnow
D#
S is the source domain (Exp) D is the standard result domain (Z) D is the abstract result domain (Sign)
(End example Sign2.lhs)
COMP 3610 Abstract interpreters
9
COMP 3610 Abstract interpreters
10
Safety
An abstract interpreter must never give a wrong answer. Since the abstraction is often partial, this is the point of the dont know answer. An abstract interpreter must be safe: It must never infer a property that a program does not have. This looks obvious for the signs example, but in general, proving that an abstract interpreter is safe is a non-trivial requirement. On the other hand, an abstract interpreter that always replies dont know is certainly safe, but it is of no use. The aim is to get as much information as possible without making the analysis unsafe, or too expensive (complex).
Applications of abstract interpretation
Abstract interpretation has many applications in the implementation of programming languages. Here are some from the functional world: Type-checking: Determine the type of an expression without evaluating it; Strictness analysis: If we can statically determine that a function w...