CHƢƠNG III CHƢƠNG TRÌNH THỰC NGHIỆM
3.4. Kết luận chƣơng 3
Trong chƣơng này, tôi đã giới thiệu về phần mềm TVLA, các kiến thức cơ bản và nền tảng toán học của TVLA. giới thiệu bài tốn và chạy thử nghiệm chƣơng trình, đánh giá kết quả đạt đƣợc từ việc phân tích bài tốn đã đƣa ra bằng TVLA.
54
KẾT LUẬN VÀ HƢỚNG PHÁT TRIỂN
Phân tích tĩnh chƣơng trình, đặc biệt là phƣơng pháp giải thích trừu tƣợng hiện đang là một lĩnh vực nghiên cứu rộng lớn, mới mẻ và có tính mở, còn rất nhiều vấn đề cần tiếp tục nghiên cứu và phát triển. Trong giới hạn đồ án trình bày tổng quan về phân tích tĩnh chƣơng trình nói chung và phƣơng pháp giải thích trừu tƣợng trong phân tích tĩnh chƣơng trình nói riêng, đặc biệt tơi đã trình bày đƣợc các vấn đề liên quan đến giải thích trừu tƣợng trên cơ sở phân tích sơ đồ luồng điều khiển, và đã áp dụng đƣợc thành công bộ công cụ phân tích mã nguồn tĩnh sử dụng phƣơng pháp nêu trên. Nhƣng do đây là một vấn đề rộng lớn phải tốn nhiều thời gian, nhân lực và phƣơng tiện nên tôi chỉ phản ảnh đƣợc một phần trong lĩnh vực này. Mặc dù vậy, đồ án cũng đã đáp ứng đƣợc mục đích và u cầu đƣa ra đó là:
Tìm hiểu, giới thiệu tổng quan về phân tích tĩnh chƣơng trình.
Giới thiệu phân tích tĩnh chƣơng trình bằng phƣơng pháp giải thích trừu tƣợng và các vấn đề liên quan.
Trình bày đƣợc thuật tốn, cách mơ phỏng trừu tƣợng bằng cấu trúc 2- logic và cấu trúc 3-logic.
Vận dụng công cụ mã nguồn mở để demo thuật toán và đánh giá kết quả đạt đƣợc.
Phân tích tĩnh chƣơng trình nói chung và phân tích tĩnh chƣơng trình sử dụng giải thích trừu tƣợng nói riêng có thể ứng dụng rất nhiều trong lĩnh vực khoa học máy tính và trong các lĩnh vực khác nhằm nâng cao tính hiệu quả của các phần mềm điều khiển và quản lý. Việc nghiên cứu, ứng dụng phân tích tĩnh là rất cần thiết nên đƣợc chú trọng nhƣ một môn khoa học, đặc biệt nên phát triển nhƣ một lĩnh vực trong công nghệ phần mềm.
55
TÀI LIỆU THAM KHẢO
[1] David Schmidt (2005), Foundations of abstract interpretation, Kansas State University
http://santos.cis.ksu.edu/schmidt/Escuela03/WSSA/talk2p.pdf [2] Course (2005), Abstract interpretation
http://web.mit.edu/afs/athena.mit.edu/course/16/16.399/www/ [3] David Schmidt (2004), Applications and logics for static
analysis, Kansas State University
http://santos.cis.ksu.edu/schmidt/Escuela03/WSSA/talk4p.pdf [4] Arnaud Venet và Guillaume Brat, Static Program Analysis
using Abstract Interpretation, Kestrel Technology
NASA Ames Research Center Moffett Field [5] P. Cousot (Aug 5, 2008) Abstract Interpretation
[6] Tel Aviv University, Tvla: a system for generating abstract interpreters
http://www.cs.tau.ac.il/~tvla/ifip2004.pdf Website tham khảo:
[7] Abstract Interpretation
http://web.mit.edu/afs/athena.mit.edu/course/16/16.399/www/ [8] Abstract interpretation and static analysis
http://santos.cis.ksu.edu/schmidt/Escuela03/home.html
[9] Computer Science Departmen
http://www.di.ens.fr/WebHome.html.en [10] Tel Aviv University
56
PHỤ LỤC
1. Thuật tốn phân tích mối quan hệ vơ hạn thơng qua lặp tiến/lùi chi tiết (* main.ml = main-iter-fw-bw.ml *) open Program_To_Abstract_Syntax open Labels open Pretty_Print open Lpretty_Print open Abstract_To_Linear_Syntax open Linear_Syntax open Aenv open Acom open Bcom
let _ = let narrowing_limit = 100 in
let arg = if (Array.length Sys.argv) = 1 then "" else Sys.argv.(1) in
Random.self_init ();
let p = (abstract_syntax_of_program arg) in (print_string "** Program:\n";
pretty_print p;
let p’ = (linearize_com p) in
print_string "** Linearized program:\n"; lpretty_print p’;
init ();
let rec iterate pre n =
(print_string "** Precondition:\n"; print pre;
let post = (acom p’ pre (after p’)) in (print_string "** Postcondition:\n";
57
print post;
let pre’ = (bcom p’ post (at p’)) in (if (Aenv.eq pre pre’) then
(print_string "stable precondition after "; print_int n;print_string " iteration(s).\n") else if (n < narrowing_limit) then
(print_string "unstable precondition after "; print_int n;print_string " iteration(s).\n"; iterate pre’ (n+1))
else
(print_string "stable stopped "; print_int n; print_string " iterations (narrowing).\n")))) in iterate (initerr ()) 1;
quit ())
2. Các định nghĩa chức năng trừu tƣợng trong action.tvp.
%action uninterpreted() { %t "uninterpreted" } %action skip() { %t "skip" } ///////////////////////////////////////////////////////////////////////////
// Actions for statements manipulating pointer variables and pointer fields
58 %t lhs + " = NULL" { lhs(v) = 0 } } %action Copy_Var_L(lhs, rhs) { %t lhs + " = " + rhs %f { rhs(v) } { lhs(v) = rhs(v) } } %action Malloc_L(lhs) { %t lhs + " = (L) malloc(sizeof(struct node)) " %new { lhs(v) = isNew(v) t[n](v_1, v_2) = (isNew(v_1) ? v_1 == v_2 : t[n](v_1, v_2)) r[n, lhs](v) = isNew(v) foreach(z in PVar-{lhs}) { r[n,z](v) = r[n,z](v) } is[n](v) = is[n](v) } } %action Free_L(lhs) {
59
%t "free(" + lhs + ")" %f { lhs(v) }
%message (E(v, v_1) lhs(v) & n(v, v_1)) ->
"Internal Error! " + lhs + "->" + n + " != NULL" { t[n](v_1, v_2) = t[n](v_1, v_2) foreach(z in PVar) { r[n,z](v) = r[n,z](v) } is[n](v) = is[n](v) } %retain !lhs(v) } %action Get_Next_L(lhs, rhs) { %t lhs + " = " + rhs + "->" + n
%f { E(v_1, v_2) rhs(v_1) & n(v_1, v_2) & t[n](v_2, v) } %message (!E(v) rhs(v)) ->
"Illegal dereference to\n" + n + " component of " + rhs { lhs(v) = E(v_1) rhs(v_1) & n(v_1, v) } } %action Set_Next_Null_L(lhs) { %t lhs + "->" + n + " = NULL" %f { lhs(v),
60
E(v_1, v_2) lhs(v_1) & n(v_1, v_2) & t[n](v_2, v) }
%message (!E(v) lhs(v)) -> "Illegal dereference to\n" + n + " component of " + lhs { n(v_1, v_2) = n(v_1, v_2) & !lhs(v_1) } } %action Set_Next_L(lhs, rhs) { %t lhs + "->" + n + " = " + rhs %f { lhs(v), rhs(v),
// optimized change-formula for t[n] upate-formula E(v_4) rhs(v_4) & t[n](v_4, v_2)
}
%message (E(v_1, v_2) lhs(v_1) & n(v_1, v_2)) -> "Internal Error! " + lhs + "->" + n + " != NULL"
%message (E(v_1, v_2) lhs(v_1) & rhs(v_2) & t[n](v_2, v_1)) -> "A cycle may be introduced\nby assignment " + lhs + "->" + n + "=" + rhs { n(v_1, v_2) = n(v_1, v_2) | lhs(v_1) & rhs(v_2) } } //////////////////////////////////////////////////////////////////
61 // equality tests. %action Is_Not_Null_Var(lhs) { %t lhs + " != NULL" %f { lhs(v) } %p E(v) lhs(v) } %action Is_Null_Var(lhs) { %t lhs + " == NULL" %f { lhs(v) } %p !(E(v) lhs(v)) } %action Is_Eq_Var(lhs, rhs) { %t lhs + " == " + rhs %f { lhs(v), rhs(v) } %p A(v) lhs(v) <-> rhs(v) } %action Is_Not_Eq_Var(lhs, rhs) { %t lhs + " != " + rhs %f { lhs(v), rhs(v) } %p !A(v) lhs(v) <-> rhs(v) } /////////////////////////////////////////
62
%action Assert_ListInvariants(lhs) { %t "assertListInvariants(" + lhs + ")" %f { lhs(v) }
%p E(v) r[n,lhs](v) & is[n](v)
%message ( E(v) r[n,lhs](v) & is[n](v) ) ->
"The list pointed by " + lhs + " may be shared!" } %action Assert_No_Leak(lhs) { %t "assertNoLeak(" + lhs + ")" %f { lhs(v) } %p E(v) !r[n,lhs](v) %message ( E(v) !r[n,lhs](v) ) ->
"There may be a list element not reachable from variable " + lhs + "!"
}
3. Các định nghĩa chức năng trừu tƣợng trong predicates.tvp.
// For every program variable z there is a unary predicate that holds for
// list elements pointed by z.
// The unique property is used to convey the fact that the predicate can hold
// for at most one individual.
// The pointer property is a visualization hint for graphical renderers. foreach (z in PVar) {
%p z(v_1) unique pointer }
63
// The predicate n represents the n field of the list data type. %p n(v_1, v_2) function acyclic
/////////////////////////////////////////////
// Instrumentation (i.e., derived) predicates
// The is[n] predicate holds for list elements pointed by two different // list elements.
%i is[n](v) = E(v_1, v_2) (v_1 != v_2 & n(v_1, v) & n(v_2, v))
// The t[n] predicate records transitive reflexive reachability between // list elements along the n field.
%i t[n](v_1, v_2) = n*(v_1, v_2) transitive reflexive
// Integrity constraints for transitive reachability %r !t[n](v_1, v_2) ==> !n(v_1, v_2)
%r !t[n](v_1, v_2) ==> v_1 != v_2
%r E(v_1) (t[n](v_1, v_2) & t[n](v_1, v_3) & !t[n](v_2, v_3)) ==> t[n](v_3, v_2)
// For every program variable z the predicate r[n,z] holds for individual
// v when v is reachable from variable z along the n field (more formally,
// the corresponding list element is reachable from z). foreach (z in PVar) {
%i r[n,z](v) = E(v_1) (z(v_1) & t[n](v_1, v)) }
64
4. Dữ liệu đầu vào của TVLA phân tích chức năng tạo danh sách liên kết creat.tvp kết creat.tvp /////// // Sets %s PVar {x, f} #include "predicates.tvp" %% #include "actions.tvp" %% /////////////////////////////////////////////////////////////////////////
// Transition system for a function that creates new list of elements and
// appends them to the list pointed by x.
L1 uninterpreted() L2 // for (i=0; i<size; i++) { L1 uninterpreted() exit
L2 Malloc_L(f) L3 // f = malloc(sizeof(struct node)); L3 Set_Next_Null_L(f) L4 // f->n = NULL;
L4 Set_Next_L(f, x) L5 // f->n = x; L5 Copy_Var_L(x, f) L1 // x = f; // }
exit Assert_ListInvariants(x) error exit Assert_No_Leak(x) error