Download presentation

Presentation is loading. Please wait.

Published byAmia Leach Modified over 3 years ago

1
Technologies for finding errors in object-oriented software K. Rustan M. Leino Microsoft Research, Redmond, WA Lecture 0 Summer school on Formal Models of Software 1 Sep 2003, Tunis, Tunisia

2
Motivation

3
Software development problem Software construction and maintenance are expensive Reliability is costly and difficult to achieve

4
Vision Increased programmer productivity and program reliability through increased rigor Record design decisions +Utilize automatic checking =Detect errors and improve maintainability

5
User's view Program with specifications Error messages public class Bag { private /*@non_null*/ int[] a; private int n; //@ invariant 0 <= n && n <= a.length; public Bag(/*@non_null*/ int[] initialElements) { n = initialElements.length; a = new int[n]; System.arraycopy(initialElements, 0, a, 0, n); } public void add(int x) { if (n == a.length) { int[] b = new int[2*(a.length+1)]; System.arraycopy(a, 0, b, 0, n); a = b; } a[n] = x; n++; } public int extractMin() { int m = Integer.MAX_VALUE; int mindex = 0; for (int i = 0; i < n; i++) { if (a[i] < m) { mindex = i; m = a[i]; } } if (0 < n) { n--; a[mindex] = a[n]; } return m; } // The program text continues down here, but if youre // reading this, you probably arent paying attention to // the talk. Bag.java:18: Array index possibly too large

6
Extended Static Checker for Java (ESC/Java) Built at Compaq SRC Input: Java + user-supplied annotations Annotation language captures programmer design decisions Powered by program semantics and automatic theorem proving Performs modular checking

7
ESC/Java demo

8
Program checker design tradeoffs Missed errors Spurious warnings Annotation overhead Performance

9
Tool architecture Translator Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Valid Resource exhausted

10
Tool architecture, detail Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator

11
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Tool architecture, detail Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator

12
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Annotation language Simple – non_null Method annotations – requires E; – modifies w; – ensures E; – exsures (T x) E; Object invariants – invariant E;

13
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Annotation language Simple – non_null Method annotations – requires E; – modifies w; – ensures E; – exsures (T x) E; Object invariants – invariant E;

14
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Annotation language Specification expressions – side-effect free Java expressions no ++, no method calls – result, old(E) ensures result == old(x); – ==> – (forall T x; E), (exists T x; E) (forall int j; 0 a[j] > 0); – typeof(E), type(T), <: requires typeof(x) == typeof(this);

15
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Annotation language Specification expressions – side-effect free Java expressions no ++, no method calls – result, old(E) ensures result == old(x); – ==> – (forall T x; E), (exists T x; E) (forall int j; 0 a[j] > 0); – typeof(E), type(T), <: requires typeof(x) == typeof(this);

16
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Annotation language Concurrency – monitored_by lock /*@ monitored_by this */ long x; – lockset[lock] requires lockset[this]; – lock0 < lock1 – max(lockset) requires max(lockset) < this;

17
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Annotation language Concurrency – monitored_by lock /*@ monitored_by this */ long x; – lockset[lock] requires lockset[this]; – lock0 < lock1 – max(lockset) requires max(lockset) < this;

18
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Annotation language Ghost variables – ghost public T x; ghost public int objectState; ghost public TYPE elementType; – set x = E; set objectState = Open; set elementType = type(T);

19
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Annotation language Ghost variables – ghost public T x; ghost public int objectState; ghost public TYPE elementType; – set x = E; set objectState = Open; set elementType = type(T);

20
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Annotation language Miscellaneous – assert E; – assume E; assume x >= 0; // because x == y*y – nowarn x = a[j]; //@ nowarn – axiom E; axiom (forall int x; x 2 >= 0);

21
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Sugared commands S,T::=assert E |assume E |x = E |raise |S ; T |S ! T |S [] T |loop {inv E} S T end |call x = t.m(E) |…

22
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Sugared commands x = t.f.g; assert t null; tmp = select(f, t); assert tmp null; x = select(g, tmp) if (x = 0; */ (assume x < 0; x = -x []assume (x < 0) ); assert x >= 0

23
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Sugared commands x = t.f.g; assert lblneg(Null@58.9, t null); tmp = select(f, t); assert lblneg(Null@58.11, tmp null); x = select(g, tmp) if (x = 0; */ (assume x < 0; assume lblpos(Then^280:7, true); x = -x []assume (x < 0); assume lblpos(Else^280:7, true) ); assert x >= 0

24
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Primitive commands S,T::=assert E |assume E |x = E |raise |S ; T |S ! T |S [] T |loop {inv E} S T end |call x = t.m(E) |…

25
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Primitive commands //@ requires Pre; modifies w; ensures Post; X m(U u); call x = t.m(E) var u in u = E; assert Pre; var w 0 in w 0 = w; havoc w; assume Post; x = result end

26
|raise |S ; T |S ! T |S [] T Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Passive commands S,T::=assert E |assume E |x = E

27
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Passive commands if (x = 0; */ (assume x 0 < 0; x 1 = -x 0 ; x 2 = x 1 []assume (x 0 < 0); x 2 = x 0 ); assert x 2 >= 0

28
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Passive commands if (x = 0; */ (assume x 0 < 0; assume x 1 == -x 0 ; assume x 2 == x 1 []assume (x 0 < 0); assume x 2 == x 0 ); assert x 2 >= 0

29
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Weakest preconditions A Hoare triple {P} S {Q} says that if command S is started in a state satisfying P, then S terminates without error in a state satisfying Q The weakest precondition of a command S with respect to a postcondition Q, written wp(S, Q), is the weakest P such that {P} S {Q}

30
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Weakest preconditions wp(assert E, Q) = E && Q wp(assume E, Q) = E ==> Q wp(S;T, Q) = wp(S, wp(T,Q)) wp(S [] T, Q) = wp(S, Q) && wp(T, Q) wp(S, Q) = wp(S, true) && wlp(S, Q) wlp(S, Q) = wlp(S, false) || Q

31
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Verification condition Universal background predicate – (t t <: t) Type-specific background predicate – Bag <: java.lang.Object Verification condition: BP Univ && BP T ==> VC method

32
(BG_PUSH (AND (<: T_T |T_java.lang.Object|) (EQ T_T (asChild T_T |T_java.lang.Object|)) (DISTINCT arrayType |T_boolean| |T_char| |T_byte| |T_short| |T_int| |T_long| |T_float| |T_double| |T_.TYPE| T_T |T_java.lang.Object|))) (EXPLIES (LBLNEG |vc.T.abs.2.2| (IMPLIES (AND (EQ |elems@pre| elems) (EQ elems (asElems elems)) (< (eClosedTime elems) alloc) (EQ LS (asLockSet LS)) (EQ |alloc@pre| alloc)) (NOT (AND (EQ |@true| (is |x:2.21| T_int)) (OR (AND (OR (AND (< |x:2.21| 0) (LBLPOS |trace.Then^0,3.15| (EQ |@true| |@true|)) (EQ |x:3.17| (- 0 |x:2.21|)) (EQ |x:2.21 | |x:3.17|)) (AND (NOT (< |x:2.21| 0)) (LBLPOS |trace.Else^1,3.4| (EQ |@true| |@true|)) (EQ |x:2.21 | |x:2.21|))) (NOT (LBLNEG |Assert@4.8| (>= |x:2.21 | 0)))) (AND (OR (AND (< |x:2.21| 0) (LBLPOS |trace.Then^0,3.15| (EQ |@true| |@true|)) (EQ |x:3.17| (- 0 |x:2.21|)) (EQ |x:2.21 | |x:3.17|)) (AND (NOT (< |x:2.21| 0)) (LBLPOS |trace.Else^1,3.4| (EQ |@true| |@true|)) (EQ |x:2.21 | |x:2.21|))) (LBLNEG |Assert@4.8| (>= |x:2.21 | 0)) (NOT (LBLNEG |Exception@5.2| (EQ |ecReturn| |ecReturn|))))))))) (AND (DISTINCT |ecReturn|))) Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Verification condition class T { static int abs(int x) { if (x < 0) { x = -x; } //@ assert x >= 0; }

33
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Theorem prover: Simplify Nelson-Oppen cooperating decision procedures – conguence closure – linear arithmetic – partial orders – quantifiers Key features: – automatic: no user interaction – refutation based: searches for counterexamples – heuristics tuned for program checking – labels – time limit

34
Annotated Java program Verification condition Counterexample context Warning messages Automatic theorem prover Post processor Sugared command Primitive command Passive command Translator Counterexamples and warnings Counterexample: labels: (|IndexTooBig@26.5| |vc.Bag.add.20.2| |trace.Then^0,21.23|) context: (AND (NEQ |tmp1!a:23.23| null) (NEQ this null) (EQ |alloc@pre| alloc) (EQ |tmp4!n:26.6| 0) … (<= alloc (vAllocTime |tmp3!a:26.4|)) ) Bag: add(int)... ----------------------------------------------------------- Bag.java:26: Warning: Array index possibly too large (IndexTooBig) a[n] = x; ^ Execution trace information: Executed then branch in "Bag.java", line 21, col 23. -----------------------------------------------------------

35
Experience: annotations Capture common design decisions Suggested immediately by warnings Overhead: 4-10% of source code 1 annotation per field or parameter Most common annotations: – non_null – container element types

36
Experience: performance 50% of all methods:< 0.5 s 80% of all methods:< 1 s time limit:300 s total time for Javafe (40kloc): 65 min.

37
Related work ESC/Modula-3 Full functional specification and verification – JML, LOOP, B, Penelope,... Languages and language features – Euclid, Eiffel, Escher, Guava, Vault, Cqual,... – LCLint, refinement types, Types against races,... Other checking techniques – Abstract interpretation, PREfix, SLAM, Bandera, Java PathFinder 2, Canvas, ESP, AST Toolkit, Metal, …

38
Conclusions Using program semantics and automatic decision procedures for program analysis works! Cost effective?

39
What's needed? Semantics of programming language Specification language Programming methodology and disciplines Decision procedures Property inference Download ESC/Java (tool, documentation, sources): http://research.compaq.com/SRC/esc http://research.compaq.com

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google