file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Z3TestGen.fst | Z3TestGen.parse_dep_pair_with_refinement | val parse_dep_pair_with_refinement
(tag: parser reading)
(cond_binder: A.ident)
(cond: (unit -> ML string))
(payload_binder: A.ident)
(payload: parser not_reading)
: parser not_reading | val parse_dep_pair_with_refinement
(tag: parser reading)
(cond_binder: A.ident)
(cond: (unit -> ML string))
(payload_binder: A.ident)
(payload: parser not_reading)
: parser not_reading | let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 116,
"end_line": 632,
"start_col": 0,
"start_line": 631
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders } | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
tag: Z3TestGen.parser Z3TestGen.reading ->
cond_binder: Ast.ident ->
cond: (_: Prims.unit -> FStar.All.ML Prims.string) ->
payload_binder: Ast.ident ->
payload: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"Z3TestGen.parser",
"Z3TestGen.reading",
"Ast.ident",
"Prims.unit",
"Prims.string",
"Z3TestGen.not_reading",
"Z3TestGen.parse_dep_pair_with_refinement_gen",
"Z3TestGen.ident_to_string"
] | [] | false | false | false | false | false | let parse_dep_pair_with_refinement
(tag: parser reading)
(cond_binder: A.ident)
(cond: (unit -> ML string))
(payload_binder: A.ident)
(payload: parser not_reading)
: parser not_reading =
| parse_dep_pair_with_refinement_gen tag
(ident_to_string cond_binder)
cond
(ident_to_string payload_binder)
payload | false |
Z3TestGen.fst | Z3TestGen.parse_exact | val parse_exact (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | val parse_exact (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders } | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 769,
"start_col": 0,
"start_line": 761
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | size: (_: Prims.unit -> FStar.All.ML Prims.string) -> body: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.string",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Z3TestGen.binders",
"Prims.bool",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_parse_exact",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf"
] | [] | false | false | false | false | false | let parse_exact (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) =
| fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders } | false |
Z3TestGen.fst | Z3TestGen.mk_op | val mk_op: T.op -> option string -> ML string | val mk_op: T.op -> option string -> ML string | let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 372,
"start_col": 0,
"start_line": 348
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Target.op -> _: FStar.Pervasives.Native.option Prims.string -> FStar.All.ML Prims.string | FStar.All.ML | [
"ml"
] | [] | [
"Target.op",
"Z3TestGen.mk_app",
"FStar.Pervasives.Native.option",
"Prims.string",
"FStar.Pervasives.Native.Some",
"Ast.integer_type",
"Z3TestGen.mk_bitwise_op",
"Z3TestGen.mk_bitwise_not",
"Prims.int",
"Ast.bitfield_bit_order",
"FStar.Printf.sprintf",
"Z3TestGen.assert_some"
] | [] | false | true | false | false | false | let mk_op: T.op -> option string -> ML string =
| function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order ->
(fun arg ->
Printf.sprintf "(get-bitfield-%ssb %d %s)"
(match order with
| A.LSBFirst -> "l"
| A.MSBFirst -> "m")
size
(assert_some arg))
| T.Cast _ _ -> assert_some
| T.Ext s -> mk_app s | false |
Z3TestGen.fst | Z3TestGen.parse_pair | val parse_pair (fst snd: parser not_reading) : parser not_reading | val parse_pair (fst snd: parser not_reading) : parser not_reading | let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders } | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 573,
"start_col": 0,
"start_line": 566
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | fst: Z3TestGen.parser Z3TestGen.not_reading -> snd: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_parse_pair",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf"
] | [] | false | false | false | true | false | let parse_pair (fst snd: parser not_reading) : parser not_reading =
| fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders } | false |
Z3TestGen.fst | Z3TestGen.mk_parse_pair | val mk_parse_pair (name binders fst snd: string) : string | val mk_parse_pair (name binders fst snd: string) : string | let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 564,
"start_col": 0,
"start_line": 548
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | name: Prims.string -> binders: Prims.string -> fst: Prims.string -> snd: Prims.string
-> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | false | false | false | true | false | let mk_parse_pair (name binders fst snd: string) : string =
| let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (let ((" ^
tmp ^
" (" ^
fst ^
" " ^
input ^
")))\n (if (< (input-size " ^
tmp ^ ") 0)\n " ^ tmp ^ "\n (" ^ snd ^ " " ^ tmp ^ ")\n )\n )\n )\n" | false |
Z3TestGen.fst | Z3TestGen.parse_dep_pair_with_refinement_gen | val parse_dep_pair_with_refinement_gen
(tag: parser reading)
(cond_binder: string)
(cond: (unit -> ML string))
(payload_binder: string)
(payload: parser not_reading)
: parser not_reading | val parse_dep_pair_with_refinement_gen
(tag: parser reading)
(cond_binder: string)
(cond: (unit -> ML string))
(payload_binder: string)
(payload: parser not_reading)
: parser not_reading | let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders } | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 629,
"start_col": 0,
"start_line": 621
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
tag: Z3TestGen.parser Z3TestGen.reading ->
cond_binder: Prims.string ->
cond: (_: Prims.unit -> FStar.All.ML Prims.string) ->
payload_binder: Prims.string ->
payload: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"Z3TestGen.parser",
"Z3TestGen.reading",
"Prims.string",
"Prims.unit",
"Z3TestGen.not_reading",
"Z3TestGen.binders",
"Prims.bool",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_parse_dep_pair_with_refinement",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mkreading__item__call",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf",
"Z3TestGen.push_binder"
] | [] | false | false | false | false | false | let parse_dep_pair_with_refinement_gen
(tag: parser reading)
(cond_binder: string)
(cond: (unit -> ML string))
(payload_binder: string)
(payload: parser not_reading)
: parser not_reading =
| fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name
binders.bind
body_tag.call
cond_binder
(cond ())
payload_binder
body_payload.call);
{ call = mk_function_call name binders } | false |
Z3TestGen.fst | Z3TestGen.parse_dep_pair | val parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading)
: parser not_reading | val parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading)
: parser not_reading | let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders } | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 664,
"start_col": 0,
"start_line": 655
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
tag: Z3TestGen.parser Z3TestGen.reading ->
payload_binder: Ast.ident ->
payload: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"Z3TestGen.parser",
"Z3TestGen.reading",
"Ast.ident",
"Z3TestGen.not_reading",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_parse_dep_pair",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mkreading__item__call",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf",
"Z3TestGen.push_binder",
"Z3TestGen.ident_to_string"
] | [] | false | false | false | true | false | let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading)
: parser not_reading =
| fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders } | false |
Z3TestGen.fst | Z3TestGen.mk_parse_ifthenelse_cons | val mk_parse_ifthenelse_cons (counter: int) (name binders cond f_then f_else: string) : string | val mk_parse_ifthenelse_cons (counter: int) (name binders cond f_then f_else: string) : string | let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 687,
"start_col": 0,
"start_line": 669
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
counter: Prims.int ->
name: Prims.string ->
binders: Prims.string ->
cond: Prims.string ->
f_then: Prims.string ->
f_else: Prims.string
-> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.string",
"Prims.op_Hat",
"Prims.string_of_int",
"FStar.Printf.sprintf"
] | [] | false | false | false | true | false | let mk_parse_ifthenelse_cons (counter: int) (name binders cond f_then f_else: string) : string =
| let input = Printf.sprintf "%s-input" name in
"(define-fun " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (if (and " ^
cond ^
" (or (< (branch-index " ^
input ^
") 0) (= (branch-trace (branch-index " ^
input ^
")) " ^
string_of_int counter ^
")))\n (" ^
f_then ^
" (if (< (branch-index " ^
input ^
") 0) " ^
input ^
" (mk-state (input-size " ^
input ^
") (choice-index " ^
input ^
") (+ 1 (branch-index " ^
input ^
")))))\n (if (not " ^
cond ^
")\n (" ^
f_else ^
" " ^
input ^
")\n (mk-state -2 (choice-index " ^
input ^
") (+ (if (< (branch-index " ^
input ^
") 0) 0 1) (branch-index " ^
input ^ "))) ; this is a Z3 encoding artifact, not a parsing failure\n )\n )\n )\n" | false |
Z3TestGen.fst | Z3TestGen.parse_nlist | val parse_nlist (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | val parse_nlist (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 36,
"end_line": 853,
"start_col": 0,
"start_line": 849
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call } | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | size: (_: Prims.unit -> FStar.All.ML Prims.string) -> body: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.string",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Z3TestGen.parse_exact",
"Z3TestGen.parse_list"
] | [] | false | false | false | false | false | let parse_nlist (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) =
| parse_exact size (parse_list body) | false |
Z3TestGen.fst | Z3TestGen.parse_ifthenelse_nil | val parse_ifthenelse_nil
(cond: (unit -> ML string))
(pthen pelse: parser not_reading)
(counter: int)
: parser not_reading | val parse_ifthenelse_nil
(cond: (unit -> ML string))
(pthen pelse: parser not_reading)
(counter: int)
: parser not_reading | let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders } | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 728,
"start_col": 0,
"start_line": 721
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cond: (_: Prims.unit -> FStar.All.ML Prims.string) ->
pthen: Z3TestGen.parser Z3TestGen.not_reading ->
pelse: Z3TestGen.parser Z3TestGen.not_reading ->
counter: Prims.int
-> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.string",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Prims.int",
"Z3TestGen.binders",
"Prims.bool",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_parse_ifthenelse_nil",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf"
] | [] | false | false | false | false | false | let parse_ifthenelse_nil
(cond: (unit -> ML string))
(pthen pelse: parser not_reading)
(counter: int)
: parser not_reading =
| fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders } | false |
Z3TestGen.fst | Z3TestGen.mk_expr | val mk_expr (e: T.expr) : ML string | val mk_expr (e: T.expr) : ML string | let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 97,
"end_line": 396,
"start_col": 0,
"start_line": 384
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: Target.expr -> FStar.All.ML Prims.string | FStar.All.ML | [
"ml"
] | [
"mk_expr",
"mk_args_aux",
"mk_args"
] | [
"Target.expr",
"FStar.Pervasives.Native.fst",
"Target.expr'",
"Ast.range",
"Ast.constant",
"Z3TestGen.mk_constant",
"Prims.string",
"Ast.ident",
"Z3TestGen.ident_to_string",
"Target.op",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Z3TestGen.mk_op",
"FStar.Pervasives.Native.option",
"Z3TestGen.mk_args",
"Z3TestGen.is_bitwise_op",
"FStar.All.failwith"
] | [
"mutual recursion"
] | false | true | false | false | false | let rec mk_expr (e: T.expr) : ML string =
| match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported" | false |
Z3TestGen.fst | Z3TestGen.mk_parse_string | val mk_parse_string (name rec_call binders body terminator: string) : string | val mk_parse_string (name rec_call binders body terminator: string) : string | let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 893,
"start_col": 0,
"start_line": 873
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
] | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
name: Prims.string ->
rec_call: Prims.string ->
binders: Prims.string ->
body: Prims.string ->
terminator: Prims.string
-> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | false | false | false | true | false | let mk_parse_string (name rec_call binders body terminator: string) : string =
| let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (let ((" ^
tmp ^
" (" ^
body ^
" " ^
input ^
")))\n (if (< (choice-index (after-state " ^
tmp ^
")) 0)\n (mk-state -1 (choice-index (after-state " ^
tmp ^
")) (branch-index (after-state " ^
tmp ^
")))\n (if (= (return-value " ^
tmp ^
") " ^
terminator ^
")\n (after-state " ^
tmp ^ ")\n (" ^ rec_call ^ " (after-state " ^ tmp ^ "))\n )\n )\n )\n)\n" | false |
Z3TestGen.fst | Z3TestGen.parse_at_most | val parse_at_most (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | val parse_at_most (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 52,
"end_line": 775,
"start_col": 0,
"start_line": 771
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders } | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | size: (_: Prims.unit -> FStar.All.ML Prims.string) -> body: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.string",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Z3TestGen.parse_exact",
"Z3TestGen.parse_pair",
"Z3TestGen.parse_all_bytes"
] | [] | false | false | false | false | false | let parse_at_most (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) =
| parse_exact size (parse_pair body parse_all_bytes) | false |
Z3TestGen.fst | Z3TestGen.mk_parse_list | val mk_parse_list (name rec_call binders body: string) : string | val mk_parse_list (name rec_call binders body: string) : string | let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 837,
"start_col": 0,
"start_line": 824
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | name: Prims.string -> rec_call: Prims.string -> binders: Prims.string -> body: Prims.string
-> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | false | false | false | true | false | let mk_parse_list (name rec_call binders body: string) : string =
| let input = Printf.sprintf "%s-input" name in
"(define-fun-rec " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (if (<= (input-size " ^
input ^ ") 0)\n " ^ input ^ "\n (" ^ rec_call ^ " (" ^ body ^ " " ^ input ^ "))\n )\n)\n" | false |
Z3TestGen.fst | Z3TestGen.readable_itype_parser_suffix | val readable_itype_parser_suffix (i: I.itype) : Tot string | val readable_itype_parser_suffix (i: I.itype) : Tot string | let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 445,
"start_col": 0,
"start_line": 435
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name } | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | i: InterpreterTarget.itype -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"InterpreterTarget.itype",
"Prims.string"
] | [] | false | false | false | true | false | let readable_itype_parser_suffix (i: I.itype) : Tot string =
| match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros" | false |
Z3TestGen.fst | Z3TestGen.itype_byte_size | val itype_byte_size (i: I.itype) : Tot (option pos) | val itype_byte_size (i: I.itype) : Tot (option pos) | let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 13,
"end_line": 860,
"start_col": 0,
"start_line": 855
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | i: InterpreterTarget.itype -> FStar.Pervasives.Native.option Prims.pos | Prims.Tot | [
"total"
] | [] | [
"InterpreterTarget.itype",
"FStar.Pervasives.Native.Some",
"Prims.pos",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option"
] | [] | false | false | false | true | false | let itype_byte_size (i: I.itype) : Tot (option pos) =
| match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None | false |
Z3TestGen.fst | Z3TestGen.parse_list | val parse_list (body: parser not_reading) : Tot (parser not_reading) | val parse_list (body: parser not_reading) : Tot (parser not_reading) | let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call } | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 847,
"start_col": 0,
"start_line": 839
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | body: Z3TestGen.parser Z3TestGen.not_reading -> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_parse_list",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf",
"Z3TestGen.mk_function_call"
] | [] | false | false | false | true | false | let parse_list (body: parser not_reading) : Tot (parser not_reading) =
| fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call } | false |
Z3TestGen.fst | Z3TestGen.mk_parse_ifthenelse_nil | val mk_parse_ifthenelse_nil (counter: int) (name binders cond f_then f_else: string) : string | val mk_parse_ifthenelse_nil (counter: int) (name binders cond f_then f_else: string) : string | let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 719,
"start_col": 0,
"start_line": 698
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders } | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
counter: Prims.int ->
name: Prims.string ->
binders: Prims.string ->
cond: Prims.string ->
f_then: Prims.string ->
f_else: Prims.string
-> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.string",
"Prims.op_Hat",
"Prims.string_of_int",
"Prims.op_Addition",
"FStar.Printf.sprintf"
] | [] | false | false | false | true | false | let mk_parse_ifthenelse_nil (counter: int) (name binders cond f_then f_else: string) : string =
| let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (let ((" ^
tmp ^
" (if (< (branch-index " ^
input ^
") 0) " ^
input ^
" (mk-state (input-size " ^
input ^
") (choice-index " ^
input ^
") (+ 1 (branch-index " ^
input ^
"))))))\n (if (and " ^
cond ^
" (or (< (branch-index " ^
input ^
") 0) (= (branch-trace (branch-index " ^
input ^
")) " ^
string_of_int counter ^
")))\n (" ^
f_then ^
" " ^
tmp ^
")\n (if (and (not " ^
cond ^
") (or (< (branch-index " ^
input ^
") 0) (= (branch-trace (branch-index " ^
input ^
")) " ^
string_of_int (1 + counter) ^
")))\n (" ^
f_else ^
" " ^
tmp ^
")\n (mk-state -2 (choice-index " ^
tmp ^
") (+ (if (< (branch-index " ^
input ^
") 0) 0 1) (branch-index " ^
input ^ "))) ; this is a Z3 encoding artifact, not a parsing failure\n )\n )\n )\n )\n" | false |
Z3TestGen.fst | Z3TestGen.mk_parse_exact | val mk_parse_exact (name binders body size: string) : string | val mk_parse_exact (name binders body size: string) : string | let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 759,
"start_col": 0,
"start_line": 730
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders } | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | name: Prims.string -> binders: Prims.string -> body: Prims.string -> size: Prims.string
-> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | false | false | false | true | false | let mk_parse_exact (name binders body size: string) : string =
| let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (let ((" ^
sz ^
" " ^
size ^
"))\n (if (< (input-size " ^
input ^
") " ^
sz ^
")\n (mk-state -1 (choice-index " ^
input ^
") (branch-index " ^
input ^
"))\n (let ((" ^
res ^
" (" ^
body ^
" (mk-state " ^
sz ^
" (choice-index " ^
input ^
") (branch-index " ^
input ^
")))))\n (mk-state\n (if (= (input-size " ^
res ^
") 0)\n (- (input-size " ^
input ^
") " ^
sz ^
")\n (if (> (input-size " ^
res ^
") 0)\n -1\n (input-size " ^
res ^
")\n )\n )\n (choice-index " ^
res ^ ")\n (branch-index " ^ res ^ ")\n )\n )\n )\n )\n)\n" | false |
Z3TestGen.fst | Z3TestGen.parse_string | val parse_string (body: parser reading) (terminator: (unit -> ML string)) : Tot (parser not_reading) | val parse_string (body: parser reading) (terminator: (unit -> ML string)) : Tot (parser not_reading) | let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call } | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 904,
"start_col": 0,
"start_line": 895
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | body: Z3TestGen.parser Z3TestGen.reading -> terminator: (_: Prims.unit -> FStar.All.ML Prims.string)
-> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"Z3TestGen.parser",
"Z3TestGen.reading",
"Prims.unit",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Z3TestGen.Mknot_reading",
"Z3TestGen.not_reading",
"Z3TestGen.mk_parse_string",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mkreading__item__call",
"FStar.Printf.sprintf",
"Z3TestGen.mk_function_call"
] | [] | false | false | false | false | false | let parse_string (body: parser reading) (terminator: (unit -> ML string)) : Tot (parser not_reading) =
| fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call } | false |
Z3TestGen.fst | Z3TestGen.smt_type_of_typ | val smt_type_of_typ (t: T.typ) : Tot string | val smt_type_of_typ (t: T.typ) : Tot string | let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 14,
"end_line": 1009,
"start_col": 0,
"start_line": 1006
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Target.typ -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Target.typ",
"Z3TestGen.arg_type_of_typ",
"FStar.Pervasives.Native.option",
"Z3TestGen.arg_type",
"Prims.string"
] | [] | false | false | false | true | false | let smt_type_of_typ (t: T.typ) : Tot string =
| match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int" | false |
Z3TestGen.fst | Z3TestGen.mk_definition | val mk_definition (name binders typ body: string) : Tot string | val mk_definition (name binders typ body: string) : Tot string | let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 56,
"end_line": 1021,
"start_col": 0,
"start_line": 1015
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | name: Prims.string -> binders: Prims.string -> typ: Prims.string -> body: Prims.string
-> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.op_Hat"
] | [] | false | false | false | true | false | let mk_definition (name binders typ body: string) : Tot string =
| "(define-fun " ^ name ^ " (" ^ binders ^ ") " ^ typ ^ " " ^ body ^ ")" | false |
LowParse.Spec.VLData.fsti | LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd_chain | val serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s')
)) | val serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s')
)) | let serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
parse_bounded_vldata_strong_pred min max s y /\ (
let y : parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s'
)))
= serialize_bounded_vldata_strong_upd min max s x y;
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
seq_upd_seq_right_to_left sx' lm sx i' s';
Seq.lemma_split sx' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
seq_upd_seq_seq_upd_seq_slice sx' lm (Seq.length sx') i' s' | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 61,
"end_line": 769,
"start_col": 0,
"start_line": 735
} | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
)
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == Seq.length b
)))) =
let (Some (len, consumed1)) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b
let serialize_vldata_gen_correct
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) (Seq.append b1 b2) in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == sz + Seq.length b2
)))) =
seq_slice_append_l b1 b2;
seq_slice_append_r b1 b2;
serialize_vldata_gen_correct_aux sz f p (Seq.append b1 b2) b1 b2
let serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted == Some (input, Seq.length formatted))
= let sz = l in
let sp = serialize s input in
let nlen = Seq.length sp in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
M.pow2_le_compat (FStar.Mul.op_Star 8 sz) (FStar.Mul.op_Star 8 (log256' max));
assert (U32.v len < pow2 (FStar.Mul.op_Star 8 sz));
let (len: bounded_integer sz) = len in
let slen = serialize (serialize_bounded_integer sz) len in
assert (Seq.length slen == sz);
let pslen = parse (parse_bounded_integer sz) slen in
assert (Some? pslen);
let (Some (len', consumed_len')) = pslen in
assert (len == len');
assert (in_bounds min max len' == true);
assert (Seq.length sp == U32.v len);
let psp = parse p sp in
assert (Some? psp);
let (Some (_, consumed_p)) = psp in
assert ((consumed_p <: nat) == Seq.length sp);
serialize_vldata_gen_correct sz (in_bounds min max) p
slen
sp
;
()
let serialize_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s))
= Classical.forall_intro (serialize_bounded_vldata_strong_correct min max l s);
serialize_bounded_vldata_strong_aux min max l s
let serialize_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong min max s))
= serialize_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_precond
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(k: parser_kind)
: GTot bool
= match k.parser_kind_high with
| None -> false
| Some max' -> min <= k.parser_kind_low && max' <= max
let serialize_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: Lemma
( let Some (_, consumed) = parse p (serialize s x) in
let y = serialize_bounded_vldata_strong_aux min max (log256' max) s (x <: parse_bounded_vldata_strong_t min max s) in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y))
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_strong_correct min max (log256' max) s x;
()
let serialize_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: GTot (y: bytes { parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y) } )
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_correct min max s x;
serialize_bounded_vldata_strong_aux min max (log256' max) s x
let serialize_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
: Tot (serializer (parse_bounded_vldata min max p))
= serialize_bounded_vldata' min max s
let serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy
))
= let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let sy = serialize s y in
let sy' = serialize (serialize_bounded_vldata_strong min max s) y in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
assert (lm + Seq.length sy == Seq.length sx');
seq_upd_seq_right sx' sy;
Seq.lemma_split sx' lm;
Seq.lemma_split sy' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
Seq.lemma_append_inj (Seq.slice sy' 0 lm) (Seq.slice sy' lm (Seq.length sy')) sz sy;
assert (sy' `Seq.equal` seq_upd_seq sx' lm sy)
let serialize_bounded_vldata_strong_upd_bw
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx 0 sy
))
= serialize_bounded_vldata_strong_upd min max s x y | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
s: LowParse.Spec.Base.serializer p ->
x: LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s ->
y: t ->
i': Prims.nat ->
s': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
(let sx = LowParse.Spec.Base.serialize s x in
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx /\
LowParse.Spec.Base.serialize s y == LowParse.Spec.Base.seq_upd_seq sx i' s'))
(ensures
LowParse.Spec.VLData.parse_bounded_vldata_strong_pred min max s y /\
(let y = y in
let sx' =
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
x
in
let lm = LowParse.Spec.BoundedInt.log256' max in
lm + FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) == FStar.Seq.Base.length sx' /\
lm + i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx' /\
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
y ==
LowParse.Spec.Base.seq_upd_seq sx' (lm + i') s')) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.seq_upd_seq_seq_upd_seq_slice",
"LowParse.Bytes.byte",
"FStar.Seq.Base.length",
"Prims.unit",
"FStar.Seq.Properties.lemma_append_inj",
"FStar.Seq.Base.slice",
"FStar.Seq.Properties.lemma_split",
"LowParse.Spec.Base.seq_upd_seq_right_to_left",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.BoundedInt.parse_bounded_integer_kind",
"LowParse.Spec.BoundedInt.bounded_integer",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.BoundedInt.serialize_bounded_integer",
"FStar.UInt32.uint_to_t",
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd",
"Prims.op_Addition",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowParse.Spec.Base.seq_upd_seq",
"Prims.squash",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"Prims.int",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s')
)) =
| serialize_bounded_vldata_strong_upd min max s x y;
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
seq_upd_seq_right_to_left sx' lm sx i' s';
Seq.lemma_split sx' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
seq_upd_seq_seq_upd_seq_slice sx' lm (Seq.length sx') i' s' | false |
Z3TestGen.fst | Z3TestGen.produce_definition | val produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: (string -> ML unit))
: ML unit | val produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: (string -> ML unit))
: ML unit | let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body)) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 91,
"end_line": 1031,
"start_col": 0,
"start_line": 1023
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
i: Ast.ident ->
param: Prims.list Target.param ->
typ: Target.typ ->
body: Target.expr ->
out: (_: Prims.string -> FStar.All.ML Prims.unit)
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Ast.ident",
"Prims.list",
"Target.param",
"Target.typ",
"Target.expr",
"Prims.string",
"Prims.unit",
"Z3TestGen.mk_definition",
"Z3TestGen.ident_to_string",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.smt_type_of_typ",
"Z3TestGen.mk_expr",
"Z3TestGen.binders",
"Z3TestGen.binders_of_params"
] | [] | false | true | false | false | false | let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: (string -> ML unit))
: ML unit =
| let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body)) | false |
Z3TestGen.fst | Z3TestGen.prog | val prog : Type0 | let prog = list (string & prog_def) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 35,
"end_line": 1050,
"start_col": 0,
"start_line": 1050
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
} | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.string",
"Z3TestGen.prog_def"
] | [] | false | false | false | true | true | let prog =
| list (string & prog_def) | false |
|
Z3TestGen.fst | Z3TestGen.parse_itype | val parse_itype: I.itype -> parser not_reading | val parse_itype: I.itype -> parser not_reading | let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 45,
"end_line": 500,
"start_col": 0,
"start_line": 497
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" }) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: InterpreterTarget.itype -> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"InterpreterTarget.itype",
"Z3TestGen.parse_all_bytes",
"Z3TestGen.parse_all_zeros",
"Z3TestGen.wrap_parser",
"Z3TestGen.parse_readable_itype",
"Z3TestGen.parser",
"Z3TestGen.not_reading"
] | [] | false | false | false | true | false | let parse_itype: I.itype -> parser not_reading =
| function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i) | false |
LowParse.Spec.VLData.fsti | LowParse.Spec.VLData.parse_vldata_payload_size | val parse_vldata_payload_size (sz: integer_size)
: Pure nat (requires True) (ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1)) | val parse_vldata_payload_size (sz: integer_size)
: Pure nat (requires True) (ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1)) | let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295 | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 19,
"end_line": 20,
"start_col": 0,
"start_line": 11
} | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 64,
"max_ifuel": 64,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | sz: LowParse.Spec.BoundedInt.integer_size -> Prims.Pure Prims.nat | Prims.Pure | [] | [] | [
"LowParse.Spec.BoundedInt.integer_size",
"Prims.nat",
"Prims.l_True",
"Prims.eq2",
"Prims.int",
"Prims.op_Subtraction",
"Prims.pow2",
"FStar.Mul.op_Star"
] | [] | false | false | false | false | false | let parse_vldata_payload_size (sz: integer_size)
: Pure nat (requires True) (ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1)) =
| match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295 | false |
Z3TestGen.fst | Z3TestGen.with_out_file | val with_out_file (#a: Type) (name: string) (body: ((string -> ML unit) -> ML a)) : ML a | val with_out_file (#a: Type) (name: string) (body: ((string -> ML unit) -> ML a)) : ML a | let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 1105,
"start_col": 0,
"start_line": 1097
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | name: Prims.string -> body: (_: (_: Prims.string -> FStar.All.ML Prims.unit) -> FStar.All.ML a)
-> FStar.All.ML a | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"FStar.IO.close_write_file",
"FStar.IO.write_string",
"FStar.IO.fd_write",
"FStar.IO.open_write_file"
] | [] | false | true | false | false | false | let with_out_file (#a: Type) (name: string) (body: ((string -> ML unit) -> ML a)) : ML a =
| let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res | false |
Z3TestGen.fst | Z3TestGen.parse_readable_dtyp | val parse_readable_dtyp (d: I.readable_dtyp) : Tot (parser reading) | val parse_readable_dtyp (d: I.readable_dtyp) : Tot (parser reading) | let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 52,
"end_line": 519,
"start_col": 0,
"start_line": 514
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args } | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | d: InterpreterTarget.readable_dtyp -> Z3TestGen.parser Z3TestGen.reading | Prims.Tot | [
"total"
] | [] | [
"InterpreterTarget.readable_dtyp",
"InterpreterTarget.itype",
"Z3TestGen.parse_readable_itype",
"Prims.bool",
"Ast.ident",
"Prims.list",
"InterpreterTarget.expr",
"Z3TestGen.parse_readable_app",
"Z3TestGen.parser",
"Z3TestGen.reading"
] | [] | false | false | false | true | false | let parse_readable_dtyp (d: I.readable_dtyp) : Tot (parser reading) =
| match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args | false |
Z3TestGen.fst | Z3TestGen.print_witness_as_c_gen | val print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int{len == Seq.length witness} -> ML unit))
: ML unit | val print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int{len == Seq.length witness} -> ML unit))
: ML unit | let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 1249,
"start_col": 0,
"start_line": 1234
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
witness: FStar.Seq.Base.seq Prims.int ->
f: (len: Prims.int{len == FStar.Seq.Base.length witness} -> FStar.All.ML Prims.unit)
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.eq2",
"FStar.Seq.Base.length",
"Z3TestGen.print_witness_as_c_aux",
"Prims.nat"
] | [] | false | true | false | false | false | let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int{len == Seq.length witness} -> ML unit))
: ML unit =
| let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "\n printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");\n";
f len;
out "};\n" | false |
Z3TestGen.fst | Z3TestGen.print_witness_call_as_c_aux | val print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit | val print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit | let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 13,
"end_line": 1176,
"start_col": 0,
"start_line": 1163
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> () | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
validator_name: Prims.string ->
arg_types: Prims.list Z3TestGen.arg_type ->
witness_length: Prims.nat ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"Prims.list",
"Z3TestGen.arg_type",
"Prims.nat",
"Prims.string_of_int",
"Z3TestGen.print_witness_args_as_c"
] | [] | false | true | false | false | false | let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit =
| out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);" | false |
Z3TestGen.fst | Z3TestGen.mk_args | val mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) | val mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) | let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 97,
"end_line": 396,
"start_col": 0,
"start_line": 384
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | is_bitwise_op: FStar.Pervasives.Native.option Ast.integer_type -> l: Prims.list Target.expr
-> FStar.All.ML (FStar.Pervasives.Native.option Prims.string) | FStar.All.ML | [
"ml"
] | [
"mk_expr",
"mk_args_aux",
"mk_args"
] | [
"FStar.Pervasives.Native.option",
"Ast.integer_type",
"Prims.list",
"Target.expr",
"FStar.Pervasives.Native.None",
"Prims.string",
"FStar.Pervasives.Native.Some",
"Z3TestGen.mk_args_aux",
"Z3TestGen.mk_maybe_bitwise_arg",
"Z3TestGen.mk_expr"
] | [
"mutual recursion"
] | false | true | false | false | false | let rec mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) =
| match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q) | false |
Z3TestGen.fst | Z3TestGen.produce_decls | val produce_decls (out: (string -> ML unit)) (accu: prog) (l: list I.decl) : ML prog | val produce_decls (out: (string -> ML unit)) (accu: prog) (l: list I.decl) : ML prog | let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 42,
"end_line": 1093,
"start_col": 0,
"start_line": 1092
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
accu: Z3TestGen.prog ->
l: Prims.list InterpreterTarget.decl
-> FStar.All.ML Z3TestGen.prog | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"Z3TestGen.prog",
"Prims.list",
"InterpreterTarget.decl",
"FStar.List.fold_left",
"Z3TestGen.produce_decl"
] | [] | false | true | false | false | false | let produce_decls (out: (string -> ML unit)) (accu: prog) (l: list I.decl) : ML prog =
| List.fold_left (produce_decl out) accu l | false |
Z3TestGen.fst | Z3TestGen.print_witness_args_as_c | val print_witness_args_as_c (out: (string -> ML unit)) (l: list arg_type) (args: list string)
: ML unit | val print_witness_args_as_c (out: (string -> ML unit)) (l: list arg_type) (args: list string)
: ML unit | let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> () | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 11,
"end_line": 1161,
"start_col": 0,
"start_line": 1148
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
l: Prims.list Z3TestGen.arg_type ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Pervasives.Native.Mktuple2",
"Z3TestGen.print_witness_args_as_c",
"Z3TestGen.uu___is_ArgInt",
"Prims.bool",
"FStar.Pervasives.Native.tuple2"
] | [
"recursion"
] | false | true | false | false | false | let rec print_witness_args_as_c (out: (string -> ML unit)) (l: list arg_type) (args: list string)
: ML unit =
| match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U");
out ", ";
print_witness_args_as_c out ql qargs
| _ -> () | false |
Z3TestGen.fst | Z3TestGen.print_witness_call_as_c | val print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit | val print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit | let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 1215,
"start_col": 0,
"start_line": 1178
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
positive: Prims.bool ->
validator_name: Prims.string ->
arg_types: Prims.list Z3TestGen.arg_type ->
witness_length: Prims.nat ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"Prims.bool",
"Prims.list",
"Z3TestGen.arg_type",
"Prims.nat",
"Prims.string_of_int",
"Z3TestGen.print_witness_call_as_c_aux"
] | [] | false | true | false | false | false | let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit =
| out "\n {\n uint8_t context = 0;\n uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "\n printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");\n BOOLEAN result = !EverParseIsError(output);\n BOOLEAN consumes_all_bytes_if_successful = true;\n if (result) {\n consumes_all_bytes_if_successful = (output == "
;
out (string_of_int witness_length);
out "U);\n result = consumes_all_bytes_if_successful;\n }\n if (result)\n printf (\"ACCEPTED\\n\\n\");\n else if (!consumes_all_bytes_if_successful)\n printf (\"REJECTED (not all bytes consumed)\\n\\n\");\n else\n printf (\"REJECTED (failed)\\n\\n\");\n if ("
;
if positive then out "!";
out "result)\n return 1;\n };\n" | false |
Z3TestGen.fst | Z3TestGen.module_and_validator_name | val module_and_validator_name (s: string) : ML (string & string) | val module_and_validator_name (s: string) : ML (string & string) | let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 1146,
"start_col": 0,
"start_line": 1141
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: Prims.string -> FStar.All.ML (Prims.string * Prims.string) | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"FStar.String.split",
"Prims.Cons",
"FStar.String.char",
"Prims.Nil",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"Target.validator_name",
"Prims.list",
"FStar.All.failwith"
] | [] | false | true | false | false | false | let module_and_validator_name (s: string) : ML (string & string) =
| match String.split ['.'] s with
| [modul ; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name" | false |
Z3TestGen.fst | Z3TestGen.read_witness | val read_witness (z3: Z3.z3) : ML (Seq.seq int) | val read_witness (z3: Z3.z3) : ML (Seq.seq int) | let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 28,
"end_line": 1129,
"start_col": 0,
"start_line": 1117
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | z3: Z3.Base.z3 -> FStar.All.ML (FStar.Seq.Base.seq Prims.int) | FStar.All.ML | [
"ml"
] | [] | [
"Z3.Base.z3",
"Prims.string",
"Prims.int",
"FStar.Seq.Base.empty",
"FStar.Seq.Base.seq",
"Prims.op_LessThanOrEqual",
"Prims.bool",
"FStar.Seq.Base.cons",
"Lisp.read_bare_int_from",
"Z3.Base.__proj__Mkz3__item__from_z3",
"Prims.unit",
"Z3.Base.__proj__Mkz3__item__to_z3",
"FStar.Printf.sprintf",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple2",
"Lisp.read_int_from"
] | [] | false | true | false | false | false | let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
| z3.to_z3 "(get-value (state-witness-size))\n";
let _, witness_size = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size | false |
Z3TestGen.fst | Z3TestGen.print_witness_and_call | val print_witness_and_call
(name: string)
(l: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit | val print_witness_and_call
(name: string)
(l: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit | let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 1312,
"start_col": 0,
"start_line": 1309
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
name: Prims.string ->
l: Prims.list Z3TestGen.arg_type ->
witness: FStar.Seq.Base.seq Prims.int ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Seq.Base.seq",
"Prims.int",
"Z3TestGen.print_witness",
"Prims.unit",
"FStar.IO.print_string",
"Z3TestGen.mk_witness_call"
] | [] | false | true | false | false | false | let print_witness_and_call
(name: string)
(l: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit =
| FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness | false |
Z3TestGen.fst | Z3TestGen.print_witness | val print_witness (witness: Seq.seq int) : ML unit | val print_witness (witness: Seq.seq int) : ML unit | let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 1301,
"start_col": 0,
"start_line": 1298
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | witness: FStar.Seq.Base.seq Prims.int -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.int",
"FStar.IO.print_string",
"Prims.unit",
"FStar.List.iter",
"Prims.string_of_int",
"FStar.Seq.Base.seq_to_list"
] | [] | false | true | false | false | false | let print_witness (witness: Seq.seq int) : ML unit =
| FStar.IO.print_string " produced witness: [";
List.iter (fun i ->
FStar.IO.print_string (string_of_int i);
FStar.IO.print_string "; ")
(Seq.seq_to_list witness);
FStar.IO.print_string "]\n" | false |
Z3TestGen.fst | Z3TestGen.count_args | val count_args (l: list arg_type) : Tot nat | val count_args (l: list arg_type) : Tot nat | let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 124,
"end_line": 1314,
"start_col": 0,
"start_line": 1314
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | l: Prims.list Z3TestGen.arg_type -> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Z3TestGen.arg_type",
"FStar.List.Tot.Base.length",
"FStar.List.Tot.Base.filter",
"Prims.bool",
"Prims.nat"
] | [] | false | false | false | true | false | let count_args (l: list arg_type) : Tot nat =
| List.Tot.length (List.Tot.filter (function
| ArgPointer -> false
| _ -> true)
l) | false |
Z3TestGen.fst | Z3TestGen.enumerate_branch_traces | val enumerate_branch_traces (z3: Z3.z3) (max_depth: nat) : ML (list branch_trace_node) | val enumerate_branch_traces (z3: Z3.z3) (max_depth: nat) : ML (list branch_trace_node) | let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 1463,
"start_col": 0,
"start_line": 1456
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | z3: Z3.Base.z3 -> max_depth: Prims.nat -> FStar.All.ML (Prims.list Z3TestGen.branch_trace_node) | FStar.All.ML | [
"ml"
] | [] | [
"Z3.Base.z3",
"Prims.nat",
"Prims.list",
"Z3TestGen.branch_trace_node",
"Prims.unit",
"Z3.Base.__proj__Mkz3__item__to_z3",
"Z3TestGen.enumerate_branch_traces'"
] | [] | false | true | false | false | false | let enumerate_branch_traces (z3: Z3.z3) (max_depth: nat) : ML (list branch_trace_node) =
| z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res | false |
Z3TestGen.fst | Z3TestGen.witnesses_for | val witnesses_for : z3: Z3.Base.z3 ->
name: Prims.string ->
l: Prims.list Z3TestGen.arg_type ->
nargs: Prims.nat{nargs == Z3TestGen.count_args l} ->
print_test_case_mk_get_first_witness:
Prims.list ((_: FStar.Seq.Base.seq Prims.int -> _: Prims.list Prims.string
-> FStar.All.ML Prims.unit) *
(_: Prims.unit -> FStar.All.ML Prims.string)) ->
nbwitnesses: Prims.int ->
max_depth: Prims.nat
-> FStar.All.ML Prims.unit | let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 20,
"end_line": 1499,
"start_col": 0,
"start_line": 1484
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
z3: Z3.Base.z3 ->
name: Prims.string ->
l: Prims.list Z3TestGen.arg_type ->
nargs: Prims.nat{nargs == Z3TestGen.count_args l} ->
print_test_case_mk_get_first_witness:
Prims.list ((_: FStar.Seq.Base.seq Prims.int -> _: Prims.list Prims.string
-> FStar.All.ML Prims.unit) *
(_: Prims.unit -> FStar.All.ML Prims.string)) ->
nbwitnesses: Prims.int ->
max_depth: Prims.nat
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Z3.Base.z3",
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"Prims.nat",
"Prims.eq2",
"Z3TestGen.count_args",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.unit",
"Z3.Base.__proj__Mkz3__item__to_z3",
"FStar.List.iter",
"Z3TestGen.want_witnesses_with_depth",
"Z3TestGen.assert_valid_state",
"Z3TestGen.branch_trace_node",
"Z3TestGen.enumerate_branch_traces",
"Z3TestGen.mk_get_witness"
] | [] | false | true | false | false | false | let witnesses_for
(z3: Z3.z3)
(name: string)
(l: list arg_type)
(nargs: nat{nargs == count_args l})
(print_test_case_mk_get_first_witness:
list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string)))
nbwitnesses
max_depth
=
| z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter #((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n")
print_test_case_mk_get_first_witness;
z3.to_z3 "(pop)\n" | false |
|
Z3TestGen.fst | Z3TestGen.assert_valid_state | val assert_valid_state : Prims.string | let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 82,
"end_line": 1394,
"start_col": 0,
"start_line": 1393
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.string | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let assert_valid_state =
| "(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n" | false |
|
Z3TestGen.fst | Z3TestGen.mk_get_positive_test_witness | val mk_get_positive_test_witness (name: string) (l: list arg_type) : string | val mk_get_positive_test_witness (name: string) (l: list arg_type) : string | let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= (input-size state-witness) 0)) ; validator shall consume all input
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 1504,
"start_col": 0,
"start_line": 1501
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree
let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | name: Prims.string -> l: Prims.list Z3TestGen.arg_type -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type"
] | [] | false | false | false | true | false | let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
| "\n(assert (= (input-size state-witness) 0)) ; validator shall consume all input\n" | false |
Vale.SHA.PPC64LE.Rounds.fst | Vale.SHA.PPC64LE.Rounds.va_lemma_Loop_rounds_16_47 | val va_lemma_Loop_rounds_16_47 : va_b0:va_code -> va_s0:va_state -> i:nat -> k_b:buffer128 ->
block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop_rounds_16_47 i) va_s0 /\ va_get_ok va_s0 /\ (l_or
(i == 16) (i == 32) /\ validSrcAddrsOffset128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 6 va_s0)
k_b (i `op_Division` 4 + 1) 4 (va_get_mem_layout va_s0) Secret /\ (let ks = buffer128_as_seq
(va_get_mem_heaplet 0 va_s0) k_b in k_reqs ks /\ va_get_reg 6 va_s0 + 64 < pow2_64 /\ (let hash
= repeat_range_vale i block hash_orig in l_and (l_and (l_and (l_and (l_and (l_and (l_and
((va_get_vec 16 va_s0).hi3 == word_to_nat32 (index hash 0)) ((va_get_vec 17 va_s0).hi3 ==
word_to_nat32 (index hash 1))) ((va_get_vec 18 va_s0).hi3 == word_to_nat32 (index hash 2)))
((va_get_vec 19 va_s0).hi3 == word_to_nat32 (index hash 3))) ((va_get_vec 20 va_s0).hi3 ==
word_to_nat32 (index hash 4))) ((va_get_vec 21 va_s0).hi3 == word_to_nat32 (index hash 5)))
((va_get_vec 22 va_s0).hi3 == word_to_nat32 (index hash 6))) ((va_get_vec 23 va_s0).hi3 ==
add_wrap32 (word_to_nat32 (index hash 7)) (k_index ks i))) /\ l_and (l_and (l_and (l_and (l_and
(l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and ((va_get_vec 0 va_s0).hi3
== ws_opaque block i) ((va_get_vec 1 va_s0).hi3 == ws_opaque block (i - 15))) ((va_get_vec 2
va_s0).hi3 == ws_opaque block (i - 14))) ((va_get_vec 3 va_s0).hi3 == ws_opaque block (i -
13))) ((va_get_vec 4 va_s0).hi3 == ws_opaque block (i - 12))) ((va_get_vec 5 va_s0).hi3 ==
ws_opaque block (i - 11))) ((va_get_vec 6 va_s0).hi3 == ws_opaque block (i - 10))) ((va_get_vec
7 va_s0).hi3 == ws_opaque block (i - 9))) ((va_get_vec 8 va_s0).hi3 == ws_opaque block (i -
8))) ((va_get_vec 9 va_s0).hi3 == ws_opaque block (i - 7))) ((va_get_vec 10 va_s0).hi3 ==
ws_opaque block (i - 6))) ((va_get_vec 11 va_s0).hi3 == ws_opaque block (i - 5))) ((va_get_vec
12 va_s0).hi3 == ws_opaque block (i - 4))) ((va_get_vec 13 va_s0).hi3 == ws_opaque block (i -
3))) ((va_get_vec 14 va_s0).hi3 == ws_opaque block (i - 2))) ((va_get_vec 15 va_s0).hi3 ==
ws_opaque block (i - 1)) /\ l_and (l_and ((va_get_vec 24 va_s0).hi3 == k_index ks (i + 1))
((va_get_vec 24 va_s0).hi2 == k_index ks (i + 2))) ((va_get_vec 24 va_s0).lo1 == k_index ks (i
+ 3))))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(va_get_reg 6 va_sM == va_get_reg 6 va_s0 + 64 /\ (let ks = buffer128_as_seq
(va_get_mem_heaplet 0 va_sM) k_b in (let next_hash = repeat_range_vale (i + 16) block hash_orig
in l_and (l_and (l_and (l_and (l_and (l_and (l_and ((va_get_vec 16 va_sM).hi3 == word_to_nat32
(index next_hash 0)) ((va_get_vec 17 va_sM).hi3 == word_to_nat32 (index next_hash 1)))
((va_get_vec 18 va_sM).hi3 == word_to_nat32 (index next_hash 2))) ((va_get_vec 19 va_sM).hi3 ==
word_to_nat32 (index next_hash 3))) ((va_get_vec 20 va_sM).hi3 == word_to_nat32 (index
next_hash 4))) ((va_get_vec 21 va_sM).hi3 == word_to_nat32 (index next_hash 5))) ((va_get_vec
22 va_sM).hi3 == word_to_nat32 (index next_hash 6))) ((va_get_vec 23 va_sM).hi3 == add_wrap32
(word_to_nat32 (index next_hash 7)) (k_index ks (i + 16)))) /\ l_and (l_and (l_and (l_and
(l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and ((va_get_vec 0
va_sM).hi3 == ws_opaque block (i + 16)) ((va_get_vec 1 va_sM).hi3 == ws_opaque block (i + 1)))
((va_get_vec 2 va_sM).hi3 == ws_opaque block (i + 2))) ((va_get_vec 3 va_sM).hi3 == ws_opaque
block (i + 3))) ((va_get_vec 4 va_sM).hi3 == ws_opaque block (i + 4))) ((va_get_vec 5
va_sM).hi3 == ws_opaque block (i + 5))) ((va_get_vec 6 va_sM).hi3 == ws_opaque block (i + 6)))
((va_get_vec 7 va_sM).hi3 == ws_opaque block (i + 7))) ((va_get_vec 8 va_sM).hi3 == ws_opaque
block (i + 8))) ((va_get_vec 9 va_sM).hi3 == ws_opaque block (i + 9))) ((va_get_vec 10
va_sM).hi3 == ws_opaque block (i + 10))) ((va_get_vec 11 va_sM).hi3 == ws_opaque block (i +
11))) ((va_get_vec 12 va_sM).hi3 == ws_opaque block (i + 12))) ((va_get_vec 13 va_sM).hi3 ==
ws_opaque block (i + 13))) ((va_get_vec 14 va_sM).hi3 == ws_opaque block (i + 14)))
((va_get_vec 15 va_sM).hi3 == ws_opaque block (i + 15)) /\ l_and (l_and ((va_get_vec 24
va_sM).hi3 == k_index ks (i + 17)) ((va_get_vec 24 va_sM).hi2 == k_index ks (i + 18)))
((va_get_vec 24 va_sM).lo1 == k_index ks (i + 19)))) /\ va_state_eq va_sM (va_update_vec 26
va_sM (va_update_vec 25 va_sM (va_update_vec 24 va_sM (va_update_vec 23 va_sM (va_update_vec 22
va_sM (va_update_vec 21 va_sM (va_update_vec 20 va_sM (va_update_vec 19 va_sM (va_update_vec 18
va_sM (va_update_vec 17 va_sM (va_update_vec 16 va_sM (va_update_vec 15 va_sM (va_update_vec 14
va_sM (va_update_vec 13 va_sM (va_update_vec 12 va_sM (va_update_vec 11 va_sM (va_update_vec 10
va_sM (va_update_vec 9 va_sM (va_update_vec 8 va_sM (va_update_vec 7 va_sM (va_update_vec 6
va_sM (va_update_vec 5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2
va_sM (va_update_vec 1 va_sM (va_update_vec 0 va_sM (va_update_reg 6 va_sM (va_update_ok va_sM
va_s0))))))))))))))))))))))))))))))) | val va_lemma_Loop_rounds_16_47 : va_b0:va_code -> va_s0:va_state -> i:nat -> k_b:buffer128 ->
block:block_w -> hash_orig:hash256
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Loop_rounds_16_47 i) va_s0 /\ va_get_ok va_s0 /\ (l_or
(i == 16) (i == 32) /\ validSrcAddrsOffset128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 6 va_s0)
k_b (i `op_Division` 4 + 1) 4 (va_get_mem_layout va_s0) Secret /\ (let ks = buffer128_as_seq
(va_get_mem_heaplet 0 va_s0) k_b in k_reqs ks /\ va_get_reg 6 va_s0 + 64 < pow2_64 /\ (let hash
= repeat_range_vale i block hash_orig in l_and (l_and (l_and (l_and (l_and (l_and (l_and
((va_get_vec 16 va_s0).hi3 == word_to_nat32 (index hash 0)) ((va_get_vec 17 va_s0).hi3 ==
word_to_nat32 (index hash 1))) ((va_get_vec 18 va_s0).hi3 == word_to_nat32 (index hash 2)))
((va_get_vec 19 va_s0).hi3 == word_to_nat32 (index hash 3))) ((va_get_vec 20 va_s0).hi3 ==
word_to_nat32 (index hash 4))) ((va_get_vec 21 va_s0).hi3 == word_to_nat32 (index hash 5)))
((va_get_vec 22 va_s0).hi3 == word_to_nat32 (index hash 6))) ((va_get_vec 23 va_s0).hi3 ==
add_wrap32 (word_to_nat32 (index hash 7)) (k_index ks i))) /\ l_and (l_and (l_and (l_and (l_and
(l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and ((va_get_vec 0 va_s0).hi3
== ws_opaque block i) ((va_get_vec 1 va_s0).hi3 == ws_opaque block (i - 15))) ((va_get_vec 2
va_s0).hi3 == ws_opaque block (i - 14))) ((va_get_vec 3 va_s0).hi3 == ws_opaque block (i -
13))) ((va_get_vec 4 va_s0).hi3 == ws_opaque block (i - 12))) ((va_get_vec 5 va_s0).hi3 ==
ws_opaque block (i - 11))) ((va_get_vec 6 va_s0).hi3 == ws_opaque block (i - 10))) ((va_get_vec
7 va_s0).hi3 == ws_opaque block (i - 9))) ((va_get_vec 8 va_s0).hi3 == ws_opaque block (i -
8))) ((va_get_vec 9 va_s0).hi3 == ws_opaque block (i - 7))) ((va_get_vec 10 va_s0).hi3 ==
ws_opaque block (i - 6))) ((va_get_vec 11 va_s0).hi3 == ws_opaque block (i - 5))) ((va_get_vec
12 va_s0).hi3 == ws_opaque block (i - 4))) ((va_get_vec 13 va_s0).hi3 == ws_opaque block (i -
3))) ((va_get_vec 14 va_s0).hi3 == ws_opaque block (i - 2))) ((va_get_vec 15 va_s0).hi3 ==
ws_opaque block (i - 1)) /\ l_and (l_and ((va_get_vec 24 va_s0).hi3 == k_index ks (i + 1))
((va_get_vec 24 va_s0).hi2 == k_index ks (i + 2))) ((va_get_vec 24 va_s0).lo1 == k_index ks (i
+ 3))))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(va_get_reg 6 va_sM == va_get_reg 6 va_s0 + 64 /\ (let ks = buffer128_as_seq
(va_get_mem_heaplet 0 va_sM) k_b in (let next_hash = repeat_range_vale (i + 16) block hash_orig
in l_and (l_and (l_and (l_and (l_and (l_and (l_and ((va_get_vec 16 va_sM).hi3 == word_to_nat32
(index next_hash 0)) ((va_get_vec 17 va_sM).hi3 == word_to_nat32 (index next_hash 1)))
((va_get_vec 18 va_sM).hi3 == word_to_nat32 (index next_hash 2))) ((va_get_vec 19 va_sM).hi3 ==
word_to_nat32 (index next_hash 3))) ((va_get_vec 20 va_sM).hi3 == word_to_nat32 (index
next_hash 4))) ((va_get_vec 21 va_sM).hi3 == word_to_nat32 (index next_hash 5))) ((va_get_vec
22 va_sM).hi3 == word_to_nat32 (index next_hash 6))) ((va_get_vec 23 va_sM).hi3 == add_wrap32
(word_to_nat32 (index next_hash 7)) (k_index ks (i + 16)))) /\ l_and (l_and (l_and (l_and
(l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and ((va_get_vec 0
va_sM).hi3 == ws_opaque block (i + 16)) ((va_get_vec 1 va_sM).hi3 == ws_opaque block (i + 1)))
((va_get_vec 2 va_sM).hi3 == ws_opaque block (i + 2))) ((va_get_vec 3 va_sM).hi3 == ws_opaque
block (i + 3))) ((va_get_vec 4 va_sM).hi3 == ws_opaque block (i + 4))) ((va_get_vec 5
va_sM).hi3 == ws_opaque block (i + 5))) ((va_get_vec 6 va_sM).hi3 == ws_opaque block (i + 6)))
((va_get_vec 7 va_sM).hi3 == ws_opaque block (i + 7))) ((va_get_vec 8 va_sM).hi3 == ws_opaque
block (i + 8))) ((va_get_vec 9 va_sM).hi3 == ws_opaque block (i + 9))) ((va_get_vec 10
va_sM).hi3 == ws_opaque block (i + 10))) ((va_get_vec 11 va_sM).hi3 == ws_opaque block (i +
11))) ((va_get_vec 12 va_sM).hi3 == ws_opaque block (i + 12))) ((va_get_vec 13 va_sM).hi3 ==
ws_opaque block (i + 13))) ((va_get_vec 14 va_sM).hi3 == ws_opaque block (i + 14)))
((va_get_vec 15 va_sM).hi3 == ws_opaque block (i + 15)) /\ l_and (l_and ((va_get_vec 24
va_sM).hi3 == k_index ks (i + 17)) ((va_get_vec 24 va_sM).hi2 == k_index ks (i + 18)))
((va_get_vec 24 va_sM).lo1 == k_index ks (i + 19)))) /\ va_state_eq va_sM (va_update_vec 26
va_sM (va_update_vec 25 va_sM (va_update_vec 24 va_sM (va_update_vec 23 va_sM (va_update_vec 22
va_sM (va_update_vec 21 va_sM (va_update_vec 20 va_sM (va_update_vec 19 va_sM (va_update_vec 18
va_sM (va_update_vec 17 va_sM (va_update_vec 16 va_sM (va_update_vec 15 va_sM (va_update_vec 14
va_sM (va_update_vec 13 va_sM (va_update_vec 12 va_sM (va_update_vec 11 va_sM (va_update_vec 10
va_sM (va_update_vec 9 va_sM (va_update_vec 8 va_sM (va_update_vec 7 va_sM (va_update_vec 6
va_sM (va_update_vec 5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2
va_sM (va_update_vec 1 va_sM (va_update_vec 0 va_sM (va_update_reg 6 va_sM (va_update_ok va_sM
va_s0))))))))))))))))))))))))))))))) | let va_lemma_Loop_rounds_16_47 va_b0 va_s0 i k_b block hash_orig =
let (va_mods:va_mods_t) = [va_Mod_vec 26; va_Mod_vec 25; va_Mod_vec 24; va_Mod_vec 23; va_Mod_vec
22; va_Mod_vec 21; va_Mod_vec 20; va_Mod_vec 19; va_Mod_vec 18; va_Mod_vec 17; va_Mod_vec 16;
va_Mod_vec 15; va_Mod_vec 14; va_Mod_vec 13; va_Mod_vec 12; va_Mod_vec 11; va_Mod_vec 10;
va_Mod_vec 9; va_Mod_vec 8; va_Mod_vec 7; va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec
3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 6; va_Mod_ok] in
let va_qc = va_qcode_Loop_rounds_16_47 va_mods i k_b block hash_orig in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop_rounds_16_47 i) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 139 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_get_ok va_sM) /\ (label va_range1
"***** POSTCONDITION NOT MET AT line 179 column 29 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_get_reg 6 va_sM == va_get_reg 6 va_s0 + 64) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 180 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(let ks = buffer128_as_seq (va_get_mem_heaplet 0 va_sM) k_b in label va_range1
"***** POSTCONDITION NOT MET AT line 189 column 87 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(let next_hash = repeat_range_vale (i + 16) block hash_orig in l_and (l_and (l_and (l_and
(l_and (l_and (l_and ((va_get_vec 16 va_sM).hi3 == word_to_nat32 (index next_hash 0))
((va_get_vec 17 va_sM).hi3 == word_to_nat32 (index next_hash 1))) ((va_get_vec 18 va_sM).hi3 ==
word_to_nat32 (index next_hash 2))) ((va_get_vec 19 va_sM).hi3 == word_to_nat32 (index
next_hash 3))) ((va_get_vec 20 va_sM).hi3 == word_to_nat32 (index next_hash 4))) ((va_get_vec
21 va_sM).hi3 == word_to_nat32 (index next_hash 5))) ((va_get_vec 22 va_sM).hi3 ==
word_to_nat32 (index next_hash 6))) ((va_get_vec 23 va_sM).hi3 == add_wrap32 (word_to_nat32
(index next_hash 7)) (k_index ks (i + 16)))) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 195 column 42 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and
(l_and (l_and ((va_get_vec 0 va_sM).hi3 == ws_opaque block (i + 16)) ((va_get_vec 1 va_sM).hi3
== ws_opaque block (i + 1))) ((va_get_vec 2 va_sM).hi3 == ws_opaque block (i + 2)))
((va_get_vec 3 va_sM).hi3 == ws_opaque block (i + 3))) ((va_get_vec 4 va_sM).hi3 == ws_opaque
block (i + 4))) ((va_get_vec 5 va_sM).hi3 == ws_opaque block (i + 5))) ((va_get_vec 6
va_sM).hi3 == ws_opaque block (i + 6))) ((va_get_vec 7 va_sM).hi3 == ws_opaque block (i + 7)))
((va_get_vec 8 va_sM).hi3 == ws_opaque block (i + 8))) ((va_get_vec 9 va_sM).hi3 == ws_opaque
block (i + 9))) ((va_get_vec 10 va_sM).hi3 == ws_opaque block (i + 10))) ((va_get_vec 11
va_sM).hi3 == ws_opaque block (i + 11))) ((va_get_vec 12 va_sM).hi3 == ws_opaque block (i +
12))) ((va_get_vec 13 va_sM).hi3 == ws_opaque block (i + 13))) ((va_get_vec 14 va_sM).hi3 ==
ws_opaque block (i + 14))) ((va_get_vec 15 va_sM).hi3 == ws_opaque block (i + 15))) /\ label
va_range1
"***** POSTCONDITION NOT MET AT line 196 column 98 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(l_and (l_and ((va_get_vec 24 va_sM).hi3 == k_index ks (i + 17)) ((va_get_vec 24 va_sM).hi2 ==
k_index ks (i + 18))) ((va_get_vec 24 va_sM).lo1 == k_index ks (i + 19)))))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_vec 26; va_Mod_vec 25; va_Mod_vec 24; va_Mod_vec 23; va_Mod_vec 22;
va_Mod_vec 21; va_Mod_vec 20; va_Mod_vec 19; va_Mod_vec 18; va_Mod_vec 17; va_Mod_vec 16;
va_Mod_vec 15; va_Mod_vec 14; va_Mod_vec 13; va_Mod_vec 12; va_Mod_vec 11; va_Mod_vec 10;
va_Mod_vec 9; va_Mod_vec 8; va_Mod_vec 7; va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec
3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 6; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM) | {
"file_name": "obj/Vale.SHA.PPC64LE.Rounds.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 299,
"start_col": 0,
"start_line": 253
} | module Vale.SHA.PPC64LE.Rounds
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.Stack_i
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsStack
open Vale.PPC64LE.InsVector
open Vale.SHA.PPC64LE.SHA_helpers
open Spec.SHA2
open Spec.Agile.Hash
open Spec.Hash.Definitions
open Spec.Loops
open Vale.SHA.PPC64LE.Rounds.Core
open Vale.SHA2.Wrapper
#reset-options "--z3rlimit 2000"
//-- Loop_rounds_0_15
[@ "opaque_to_smt" va_qattr]
let va_code_Loop_rounds_0_15 () =
(va_Block (va_CCons (va_code_Loop_rounds_3_7_11_body 3 (va_op_vec_opr_vec 4)) (va_CCons
(va_code_Loop_rounds_3_7_11_body 7 (va_op_vec_opr_vec 8)) (va_CCons
(va_code_Loop_rounds_3_7_11_body 11 (va_op_vec_opr_vec 12)) (va_CCons (va_Block (va_CNil ()))
(va_CCons (va_Block (va_CNil ())) (va_CCons (va_Block (va_CNil ())) (va_CCons
(va_code_Loop_rounds_1_3 ()) (va_CCons (va_code_Loop_rounds_0_59_a 0) (va_CCons
(va_code_Loop_rounds_5_7 ()) (va_CCons (va_code_Loop_rounds_0_59_b 4) (va_CCons
(va_code_Loop_rounds_9_11 ()) (va_CCons (va_code_Loop_rounds_0_59_c 8) (va_CCons
(va_code_Loop_rounds_13_15 ()) (va_CCons (va_code_Loop_rounds_0_59_d 12) (va_CCons
(va_code_Loop_rounds_16_63_body 16 (va_op_vec_opr_vec 0) (va_op_vec_opr_vec 1)
(va_op_vec_opr_vec 9) (va_op_vec_opr_vec 14)) (va_CNil ())))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop_rounds_0_15 () =
(va_pbool_and (va_codegen_success_Loop_rounds_3_7_11_body 3 (va_op_vec_opr_vec 4)) (va_pbool_and
(va_codegen_success_Loop_rounds_3_7_11_body 7 (va_op_vec_opr_vec 8)) (va_pbool_and
(va_codegen_success_Loop_rounds_3_7_11_body 11 (va_op_vec_opr_vec 12)) (va_pbool_and
(va_codegen_success_Loop_rounds_1_3 ()) (va_pbool_and (va_codegen_success_Loop_rounds_0_59_a 0)
(va_pbool_and (va_codegen_success_Loop_rounds_5_7 ()) (va_pbool_and
(va_codegen_success_Loop_rounds_0_59_b 4) (va_pbool_and (va_codegen_success_Loop_rounds_9_11
()) (va_pbool_and (va_codegen_success_Loop_rounds_0_59_c 8) (va_pbool_and
(va_codegen_success_Loop_rounds_13_15 ()) (va_pbool_and (va_codegen_success_Loop_rounds_0_59_d
12) (va_pbool_and (va_codegen_success_Loop_rounds_16_63_body 16 (va_op_vec_opr_vec 0)
(va_op_vec_opr_vec 1) (va_op_vec_opr_vec 9) (va_op_vec_opr_vec 14)) (va_ttrue ())))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop_rounds_0_15 (va_mods:va_mods_t) (in_b:buffer128) (offset:nat) (k_b:buffer128)
(block:block_w) (hash_orig:hash256) (input_BE:(seq quad32)) : (va_quickCode unit
(va_code_Loop_rounds_0_15 ())) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(va_arg34:(FStar.Seq.Base.seq Vale.Def.Types_s.quad32)) = input_BE in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 115 column 28 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(fun (_:unit) -> Vale.SHA.PPC64LE.SHA_helpers.lemma_quads_to_block_be va_arg34) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 117 column 28 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_3_7_11_body 3 (va_op_vec_opr_vec 4) in_b (offset + 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 118 column 28 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_3_7_11_body 7 (va_op_vec_opr_vec 8) in_b (offset + 2)) (va_QBind
va_range1
"***** PRECONDITION NOT MET AT line 119 column 28 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_3_7_11_body 11 (va_op_vec_opr_vec 12) in_b (offset + 3)) (fun
(va_s:va_state) _ -> va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 120 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
((fun a_539 (s_540:(FStar.Seq.Base.seq a_539)) (i_541:Prims.nat) -> let (i_515:Prims.nat) =
i_541 in Prims.b2t (Prims.op_LessThan i_515 (FStar.Seq.Base.length #a_539 s_540))) quad32
input_BE 1) (fun _ -> va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 120 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_get_vec 4 va_s == FStar.Seq.Base.index #quad32 input_BE 1) (va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 121 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
((fun a_539 (s_540:(FStar.Seq.Base.seq a_539)) (i_541:Prims.nat) -> let (i_515:Prims.nat) =
i_541 in Prims.b2t (Prims.op_LessThan i_515 (FStar.Seq.Base.length #a_539 s_540))) quad32
input_BE 2) (fun _ -> va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 121 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_get_vec 8 va_s == FStar.Seq.Base.index #quad32 input_BE 2) (va_qAssertSquash va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 122 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
((fun a_539 (s_540:(FStar.Seq.Base.seq a_539)) (i_541:Prims.nat) -> let (i_515:Prims.nat) =
i_541 in Prims.b2t (Prims.op_LessThan i_515 (FStar.Seq.Base.length #a_539 s_540))) quad32
input_BE 3) (fun _ -> va_qAssert va_range1
"***** PRECONDITION NOT MET AT line 122 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_get_vec 12 va_s == FStar.Seq.Base.index #quad32 input_BE 3) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 124 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_1_3 block) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 125 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_0_59_a 0 k_b block hash_orig) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 127 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_5_7 block) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 128 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_0_59_b 4 k_b block hash_orig) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 130 column 21 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_9_11 block) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 131 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_0_59_c 8 k_b block hash_orig) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 133 column 22 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_13_15 block) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 134 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_0_59_d 12 k_b block hash_orig) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 136 column 27 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_16_63_body 16 (va_op_vec_opr_vec 0) (va_op_vec_opr_vec 1)
(va_op_vec_opr_vec 9) (va_op_vec_opr_vec 14) block) (va_QEmpty (()))))))))))))))))))))))
[@"opaque_to_smt"]
let va_lemma_Loop_rounds_0_15 va_b0 va_s0 in_b offset k_b block hash_orig input_BE =
let (va_mods:va_mods_t) = [va_Mod_vec 26; va_Mod_vec 25; va_Mod_vec 24; va_Mod_vec 23; va_Mod_vec
22; va_Mod_vec 21; va_Mod_vec 20; va_Mod_vec 19; va_Mod_vec 18; va_Mod_vec 17; va_Mod_vec 16;
va_Mod_vec 15; va_Mod_vec 14; va_Mod_vec 13; va_Mod_vec 12; va_Mod_vec 11; va_Mod_vec 10;
va_Mod_vec 9; va_Mod_vec 8; va_Mod_vec 7; va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec
3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 6; va_Mod_reg 4; va_Mod_ok] in
let va_qc = va_qcode_Loop_rounds_0_15 va_mods in_b offset k_b block hash_orig input_BE in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_Loop_rounds_0_15 ()) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 56 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_get_ok va_sM) /\ (label va_range1
"***** POSTCONDITION NOT MET AT line 95 column 29 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_get_reg 6 va_sM == va_get_reg 6 va_s0 + 64) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 96 column 29 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_get_reg 4 va_sM == va_get_reg 4 va_s0 + 48) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 97 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(let ks = Vale.PPC64LE.Decls.buffer128_as_seq (va_get_mem_heaplet 0 va_sM) k_b in label
va_range1
"***** POSTCONDITION NOT MET AT line 106 column 85 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(let next_hash = Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale 16 block hash_orig in l_and
(l_and (l_and (l_and (l_and (l_and (l_and ((va_get_vec 16 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word next_hash 0)) ((va_get_vec 17 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word next_hash 1))) ((va_get_vec 18 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word next_hash 2))) ((va_get_vec 19 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word next_hash 3))) ((va_get_vec 20 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word next_hash 4))) ((va_get_vec 21 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word next_hash 5))) ((va_get_vec 22 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word next_hash 6))) ((va_get_vec 23 va_sM).hi3 ==
Vale.Arch.Types.add_wrap32 (Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32 (FStar.Seq.Base.index
#Vale.SHA.PPC64LE.SHA_helpers.word next_hash 7)) (Vale.SHA.PPC64LE.SHA_helpers.k_index ks 16)))
/\ label va_range1
"***** POSTCONDITION NOT MET AT line 112 column 40 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and
(l_and (l_and ((va_get_vec 0 va_sM).hi3 == Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 16)
((va_get_vec 1 va_sM).hi3 == Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 1)) ((va_get_vec 2
va_sM).hi3 == Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 2)) ((va_get_vec 3 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 3)) ((va_get_vec 4 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 4)) ((va_get_vec 5 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 5)) ((va_get_vec 6 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 6)) ((va_get_vec 7 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 7)) ((va_get_vec 8 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 8)) ((va_get_vec 9 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 9)) ((va_get_vec 10 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 10)) ((va_get_vec 11 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 11)) ((va_get_vec 12 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 12)) ((va_get_vec 13 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 13)) ((va_get_vec 14 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 14)) ((va_get_vec 15 va_sM).hi3 ==
Vale.SHA.PPC64LE.SHA_helpers.ws_opaque block 15)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 113 column 92 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(l_and (l_and ((va_get_vec 24 va_sM).hi3 == Vale.SHA.PPC64LE.SHA_helpers.k_index ks 17)
((va_get_vec 24 va_sM).hi2 == Vale.SHA.PPC64LE.SHA_helpers.k_index ks 18)) ((va_get_vec 24
va_sM).lo1 == Vale.SHA.PPC64LE.SHA_helpers.k_index ks 19))))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_vec 26; va_Mod_vec 25; va_Mod_vec 24; va_Mod_vec 23; va_Mod_vec 22;
va_Mod_vec 21; va_Mod_vec 20; va_Mod_vec 19; va_Mod_vec 18; va_Mod_vec 17; va_Mod_vec 16;
va_Mod_vec 15; va_Mod_vec 14; va_Mod_vec 13; va_Mod_vec 12; va_Mod_vec 11; va_Mod_vec 10;
va_Mod_vec 9; va_Mod_vec 8; va_Mod_vec 7; va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec
3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 6; va_Mod_reg 4; va_Mod_ok]) va_sM
va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_Loop_rounds_0_15 in_b offset k_b block hash_orig input_BE va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Loop_rounds_0_15 (va_code_Loop_rounds_0_15 ()) va_s0 in_b offset
k_b block hash_orig input_BE in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_vec 26 va_sM (va_update_vec 25 va_sM (va_update_vec 24 va_sM
(va_update_vec 23 va_sM (va_update_vec 22 va_sM (va_update_vec 21 va_sM (va_update_vec 20 va_sM
(va_update_vec 19 va_sM (va_update_vec 18 va_sM (va_update_vec 17 va_sM (va_update_vec 16 va_sM
(va_update_vec 15 va_sM (va_update_vec 14 va_sM (va_update_vec 13 va_sM (va_update_vec 12 va_sM
(va_update_vec 11 va_sM (va_update_vec 10 va_sM (va_update_vec 9 va_sM (va_update_vec 8 va_sM
(va_update_vec 7 va_sM (va_update_vec 6 va_sM (va_update_vec 5 va_sM (va_update_vec 4 va_sM
(va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1 va_sM (va_update_vec 0 va_sM
(va_update_reg 6 va_sM (va_update_reg 4 va_sM (va_update_ok va_sM
va_s0)))))))))))))))))))))))))))))));
va_lemma_norm_mods ([va_Mod_vec 26; va_Mod_vec 25; va_Mod_vec 24; va_Mod_vec 23; va_Mod_vec 22;
va_Mod_vec 21; va_Mod_vec 20; va_Mod_vec 19; va_Mod_vec 18; va_Mod_vec 17; va_Mod_vec 16;
va_Mod_vec 15; va_Mod_vec 14; va_Mod_vec 13; va_Mod_vec 12; va_Mod_vec 11; va_Mod_vec 10;
va_Mod_vec 9; va_Mod_vec 8; va_Mod_vec 7; va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec
3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 6; va_Mod_reg 4]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- Loop_rounds_16_47
[@ "opaque_to_smt" va_qattr]
let va_code_Loop_rounds_16_47 i =
(va_Block (va_CCons (va_code_Loop_rounds_16_59_a i) (va_CCons (va_code_Loop_rounds_0_59_a i)
(va_CCons (va_code_Loop_rounds_16_59_b (i + 4)) (va_CCons (va_code_Loop_rounds_0_59_b (i + 4))
(va_CCons (va_code_Loop_rounds_16_59_c (i + 8)) (va_CCons (va_code_Loop_rounds_0_59_c (i + 8))
(va_CCons (va_code_Loop_rounds_16_59_d (i + 12)) (va_CCons (va_code_Loop_rounds_0_59_d (i +
12)) (va_CNil ()))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Loop_rounds_16_47 i =
(va_pbool_and (va_pbool_and (va_codegen_success_Loop_rounds_16_59_a i)
(va_codegen_success_Loop_rounds_16_59_a i)) (va_pbool_and (va_pbool_and
(va_codegen_success_Loop_rounds_0_59_a i) (va_codegen_success_Loop_rounds_0_59_a i))
(va_pbool_and (va_pbool_and (va_codegen_success_Loop_rounds_16_59_b (i + 4))
(va_codegen_success_Loop_rounds_16_59_b (i + 4))) (va_pbool_and (va_pbool_and
(va_codegen_success_Loop_rounds_0_59_b (i + 4)) (va_codegen_success_Loop_rounds_0_59_b (i +
4))) (va_pbool_and (va_pbool_and (va_codegen_success_Loop_rounds_16_59_c (i + 8))
(va_codegen_success_Loop_rounds_16_59_c (i + 8))) (va_pbool_and (va_pbool_and
(va_codegen_success_Loop_rounds_0_59_c (i + 8)) (va_codegen_success_Loop_rounds_0_59_c (i +
8))) (va_pbool_and (va_pbool_and (va_codegen_success_Loop_rounds_16_59_d (i + 12))
(va_codegen_success_Loop_rounds_16_59_d (i + 12))) (va_pbool_and (va_pbool_and
(va_codegen_success_Loop_rounds_0_59_d (i + 12)) (va_codegen_success_Loop_rounds_0_59_d (i +
12))) (va_ttrue ())))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_Loop_rounds_16_47 (va_mods:va_mods_t) (i:nat) (k_b:buffer128) (block:block_w)
(hash_orig:hash256) : (va_quickCode unit (va_code_Loop_rounds_16_47 i)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 198 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_16_59_a i block) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 199 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_0_59_a i k_b block hash_orig) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 201 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_16_59_b (i + 4) block) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 202 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_0_59_b (i + 4) k_b block hash_orig) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 204 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_16_59_c (i + 8) block) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 205 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_0_59_c (i + 8) k_b block hash_orig) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 207 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_16_59_d (i + 12) block) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 208 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_quick_Loop_rounds_0_59_d (i + 12) k_b block hash_orig) (va_QEmpty (()))))))))))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.SHA.PPC64LE.Rounds.Core.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.checked",
"Vale.PPC64LE.InsStack.fsti.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Spec.SHA2.fsti.checked",
"Spec.Loops.fst.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.SHA.PPC64LE.Rounds.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.Rounds.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 2000,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.PPC64LE.Decls.va_code ->
va_s0: Vale.PPC64LE.Decls.va_state ->
i: Prims.nat ->
k_b: Vale.PPC64LE.Memory.buffer128 ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
hash_orig: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Prims.Ghost (Vale.PPC64LE.Decls.va_state * Vale.PPC64LE.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.PPC64LE.Decls.va_code",
"Vale.PPC64LE.Decls.va_state",
"Prims.nat",
"Vale.PPC64LE.Memory.buffer128",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Vale.PPC64LE.QuickCodes.fuel",
"Prims.unit",
"FStar.Pervasives.Native.Mktuple2",
"Vale.PPC64LE.Decls.va_fuel",
"Vale.PPC64LE.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_vec",
"Vale.PPC64LE.QuickCode.va_Mod_reg",
"Vale.PPC64LE.QuickCode.va_Mod_ok",
"Prims.Nil",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.list",
"Vale.PPC64LE.QuickCode.__proj__QProc__item__mods",
"Vale.SHA.PPC64LE.Rounds.va_code_Loop_rounds_16_47",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.tuple3",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.QuickCodes.va_wp_sound_code_norm",
"Prims.l_and",
"Vale.PPC64LE.QuickCodes.label",
"Vale.PPC64LE.QuickCodes.va_range1",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Prims.int",
"Vale.PPC64LE.Decls.va_get_reg",
"Prims.op_Addition",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Types_s.nat32",
"Vale.PPC64LE.Decls.va_get_vec",
"Vale.SHA.PPC64LE.SHA_helpers.word_to_nat32",
"FStar.Seq.Base.index",
"Vale.SHA.PPC64LE.SHA_helpers.word",
"Vale.Arch.Types.add_wrap32",
"Vale.SHA.PPC64LE.SHA_helpers.k_index",
"Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale",
"Vale.SHA.PPC64LE.SHA_helpers.ws_opaque",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.buffer128_as_seq",
"Vale.PPC64LE.Decls.va_get_mem_heaplet",
"Vale.PPC64LE.QuickCode.quickCode",
"Vale.SHA.PPC64LE.Rounds.va_qcode_Loop_rounds_16_47"
] | [] | false | false | false | false | false | let va_lemma_Loop_rounds_16_47 va_b0 va_s0 i k_b block hash_orig =
| let va_mods:va_mods_t =
[
va_Mod_vec 26; va_Mod_vec 25; va_Mod_vec 24; va_Mod_vec 23; va_Mod_vec 22; va_Mod_vec 21;
va_Mod_vec 20; va_Mod_vec 19; va_Mod_vec 18; va_Mod_vec 17; va_Mod_vec 16; va_Mod_vec 15;
va_Mod_vec 14; va_Mod_vec 13; va_Mod_vec 12; va_Mod_vec 11; va_Mod_vec 10; va_Mod_vec 9;
va_Mod_vec 8; va_Mod_vec 7; va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2;
va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 6; va_Mod_ok
]
in
let va_qc = va_qcode_Loop_rounds_16_47 va_mods i k_b block hash_orig in
let va_sM, va_fM, va_g =
va_wp_sound_code_norm (va_code_Loop_rounds_16_47 i)
va_qc
va_s0
(fun va_s0 va_sM va_g ->
let () = va_g in
label va_range1
"***** POSTCONDITION NOT MET AT line 139 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_get_ok va_sM) /\
(label va_range1
"***** POSTCONDITION NOT MET AT line 179 column 29 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(va_get_reg 6 va_sM == va_get_reg 6 va_s0 + 64) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 180 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(let ks = buffer128_as_seq (va_get_mem_heaplet 0 va_sM) k_b in
label va_range1
"***** POSTCONDITION NOT MET AT line 189 column 87 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(let next_hash = repeat_range_vale (i + 16) block hash_orig in
l_and (l_and (l_and (l_and (l_and (l_and (l_and ((va_get_vec 16 va_sM).hi3 ==
word_to_nat32 (index next_hash 0))
((va_get_vec 17 va_sM).hi3 ==
word_to_nat32 (index next_hash 1)))
((va_get_vec 18 va_sM).hi3 ==
word_to_nat32 (index next_hash 2)))
((va_get_vec 19 va_sM).hi3 == word_to_nat32 (index next_hash 3))
)
((va_get_vec 20 va_sM).hi3 == word_to_nat32 (index next_hash 4)))
((va_get_vec 21 va_sM).hi3 == word_to_nat32 (index next_hash 5)))
((va_get_vec 22 va_sM).hi3 == word_to_nat32 (index next_hash 6)))
((va_get_vec 23 va_sM).hi3 ==
add_wrap32 (word_to_nat32 (index next_hash 7)) (k_index ks (i + 16)))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 195 column 42 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (l_and (
l_and (l_and (l_and ((va_get_vec 0
va_sM)
.hi3 ==
ws_opaque block
(i + 16))
((va_get_vec 1 va_sM)
.hi3 ==
ws_opaque block
(i + 1)))
((va_get_vec 2 va_sM).hi3 ==
ws_opaque block (i + 2)))
((va_get_vec 3 va_sM).hi3 ==
ws_opaque block (i + 3)))
((va_get_vec 4 va_sM).hi3 ==
ws_opaque block (i + 4)))
((va_get_vec 5 va_sM).hi3 ==
ws_opaque block (i + 5)))
((va_get_vec 6 va_sM).hi3 ==
ws_opaque block (i + 6)))
((va_get_vec 7 va_sM).hi3 ==
ws_opaque block (i + 7)))
((va_get_vec 8 va_sM).hi3 == ws_opaque block (i + 8)
))
((va_get_vec 9 va_sM).hi3 == ws_opaque block (i + 9)))
((va_get_vec 10 va_sM).hi3 == ws_opaque block (i + 10)))
((va_get_vec 11 va_sM).hi3 == ws_opaque block (i + 11)))
((va_get_vec 12 va_sM).hi3 == ws_opaque block (i + 12)))
((va_get_vec 13 va_sM).hi3 == ws_opaque block (i + 13)))
((va_get_vec 14 va_sM).hi3 == ws_opaque block (i + 14)))
((va_get_vec 15 va_sM).hi3 == ws_opaque block (i + 15))) /\
label va_range1
"***** POSTCONDITION NOT MET AT line 196 column 98 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/thirdPartyPorts/OpenSSL/sha/Vale.SHA.PPC64LE.Rounds.vaf *****"
(l_and (l_and ((va_get_vec 24 va_sM).hi3 == k_index ks (i + 17))
((va_get_vec 24 va_sM).hi2 == k_index ks (i + 18)))
((va_get_vec 24 va_sM).lo1 == k_index ks (i + 19))))))
in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([
va_Mod_vec 26; va_Mod_vec 25; va_Mod_vec 24; va_Mod_vec 23; va_Mod_vec 22; va_Mod_vec 21;
va_Mod_vec 20; va_Mod_vec 19; va_Mod_vec 18; va_Mod_vec 17; va_Mod_vec 16; va_Mod_vec 15;
va_Mod_vec 14; va_Mod_vec 13; va_Mod_vec 12; va_Mod_vec 11; va_Mod_vec 10; va_Mod_vec 9;
va_Mod_vec 8; va_Mod_vec 7; va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec 3;
va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 6; va_Mod_ok
])
va_sM
va_s0;
(va_sM, va_fM) | false |
Z3TestGen.fst | Z3TestGen.binders_of_params | val binders_of_params : _: Prims.list (Ast.with_meta_t Ast.ident' * Target.typ) -> Z3TestGen.binders | let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 92,
"end_line": 1013,
"start_col": 0,
"start_line": 1011
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.list (Ast.with_meta_t Ast.ident' * Target.typ) -> Z3TestGen.binders | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Ast.with_meta_t",
"Ast.ident'",
"Target.typ",
"Z3TestGen.empty_binders",
"Z3TestGen.push_binder",
"Z3TestGen.ident_to_string",
"Z3TestGen.smt_type_of_typ",
"Z3TestGen.binders_of_params",
"Z3TestGen.binders"
] | [
"recursion"
] | false | false | false | true | false | let rec binders_of_params =
| function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q) | false |
|
Z3TestGen.fst | Z3TestGen.parse_dtyp | val parse_dtyp (d: I.dtyp) : Tot (parser not_reading) | val parse_dtyp (d: I.dtyp) : Tot (parser not_reading) | let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 58,
"end_line": 540,
"start_col": 0,
"start_line": 533
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | d: InterpreterTarget.dtyp -> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"InterpreterTarget.dtyp",
"InterpreterTarget.allow_reader_of_dtyp",
"Z3TestGen.wrap_parser",
"Z3TestGen.parse_readable_dtyp",
"Prims.bool",
"InterpreterTarget.itype",
"Z3TestGen.parse_itype",
"Ast.ident",
"Prims.list",
"InterpreterTarget.expr",
"Z3TestGen.parse_not_readable_app",
"Z3TestGen.parser",
"Z3TestGen.not_reading"
] | [] | false | false | false | true | false | let parse_dtyp (d: I.dtyp) : Tot (parser not_reading) =
| if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else
match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args | false |
Z3TestGen.fst | Z3TestGen.test_error_handler | val test_error_handler : Prims.string | let test_error_handler = "
static void TestErrorHandler (
const char *typename_s,
const char *fieldname,
const char *reason,
uint64_t error_code,
uint8_t *context,
EVERPARSE_INPUT_BUFFER input,
uint64_t start_pos
) {
(void) error_code;
(void) input;
if (*context) {
printf(\"Reached from position %ld: type name %s, field name %s\\n\", start_pos, typename_s, fieldname);
} else {
printf(\"Parsing failed at position %ld: type name %s, field name %s. Reason: %s\\n\", start_pos, typename_s, fieldname, reason);
*context = 1;
}
}
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 1530,
"start_col": 0,
"start_line": 1511
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree
let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n"
let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= (input-size state-witness) 0)) ; validator shall consume all input
"
let mk_get_negative_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= state-witness-input-size -1)) ; validator shall genuinely fail, we are not interested in positive cases followed by garbage
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.string | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let test_error_handler =
| "\nstatic void TestErrorHandler (\n const char *typename_s,\n const char *fieldname,\n const char *reason,\n uint64_t error_code,\n uint8_t *context,\n EVERPARSE_INPUT_BUFFER input,\n uint64_t start_pos\n) {\n (void) error_code;\n (void) input;\n if (*context) {\n printf(\"Reached from position %ld: type name %s, field name %s\\n\", start_pos, typename_s, fieldname);\n } else {\n printf(\"Parsing failed at position %ld: type name %s, field name %s. Reason: %s\\n\", start_pos, typename_s, fieldname, reason);\n *context = 1;\n }\n}\n" | false |
|
Z3TestGen.fst | Z3TestGen.do_diff_test_for | val do_diff_test_for : out_dir: Prims.string ->
counter: FStar.ST.ref Prims.int ->
cout: (_: Prims.string -> FStar.All.ML Prims.unit) ->
z3: Z3.Base.z3 ->
prog: Z3TestGen.prog ->
name1: Prims.string ->
name2: Prims.string ->
args: Prims.list Z3TestGen.arg_type ->
nargs: Prims.nat{nargs == Z3TestGen.count_args args} ->
validator_name1: Prims.string ->
validator_name2: Prims.string ->
nbwitnesses: Prims.int ->
depth: Prims.nat
-> FStar.All.ALL Prims.unit | let do_diff_test_for (out_dir: string) (counter: ref int) (cout: string -> ML unit) (z3: Z3.z3) (prog: prog) name1 name2 args (nargs: nat { nargs == count_args args }) validator_name1 validator_name2 nbwitnesses depth =
FStar.IO.print_string (Printf.sprintf ";; Witnesses that work with %s but not with %s\n" name1 name2);
witnesses_for z3 name1 args nargs ([print_diff_witness_as_c out_dir cout validator_name1 validator_name2 args counter, (fun _ -> mk_get_diff_test_witness name1 args name2)]) nbwitnesses depth | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 193,
"end_line": 1588,
"start_col": 0,
"start_line": 1586
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree
let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n"
let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= (input-size state-witness) 0)) ; validator shall consume all input
"
let mk_get_negative_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= state-witness-input-size -1)) ; validator shall genuinely fail, we are not interested in positive cases followed by garbage
"
let test_error_handler = "
static void TestErrorHandler (
const char *typename_s,
const char *fieldname,
const char *reason,
uint64_t error_code,
uint8_t *context,
EVERPARSE_INPUT_BUFFER input,
uint64_t start_pos
) {
(void) error_code;
(void) input;
if (*context) {
printf(\"Reached from position %ld: type name %s, field name %s\\n\", start_pos, typename_s, fieldname);
} else {
printf(\"Parsing failed at position %ld: type name %s, field name %s. Reason: %s\\n\", start_pos, typename_s, fieldname, reason);
*context = 1;
}
}
"
let do_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) (name1: string) (nbwitnesses: int) (depth: nat) (pos: bool) (neg: bool) : ML unit =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = (Some?.v def).args in
let modul, validator_name = module_and_validator_name name1 in
let nargs = count_args args in with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
let tasks =
begin
if pos
then [print_witness_as_c out_dir cout true validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
mk_get_positive_test_witness name1 args
))]
else []
end `List.Tot.append`
begin
if neg
then [print_witness_as_c out_dir cout false validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
mk_get_negative_test_witness name1 args
))]
else []
end
in
witnesses_for z3 name1 args nargs tasks nbwitnesses depth;
cout " return 0;
}
"
)
let mk_get_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string =
let call2 = mk_call_args name2 0 l in
Printf.sprintf
"
%s
(define-fun negative-state-witness () State (%s (mk-state initial-input-size 0 -1))) ; branch trace is ignored for the second parser
(assert (not (= (input-size negative-state-witness) 0))) ; test cases that do not consume everything are considered failing
(assert (>= (input-size negative-state-witness) -1)) ; do not record tests that artificially fail due to SMT2 encoding
"
(mk_get_positive_test_witness name1 l)
call2 | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out_dir: Prims.string ->
counter: FStar.ST.ref Prims.int ->
cout: (_: Prims.string -> FStar.All.ML Prims.unit) ->
z3: Z3.Base.z3 ->
prog: Z3TestGen.prog ->
name1: Prims.string ->
name2: Prims.string ->
args: Prims.list Z3TestGen.arg_type ->
nargs: Prims.nat{nargs == Z3TestGen.count_args args} ->
validator_name1: Prims.string ->
validator_name2: Prims.string ->
nbwitnesses: Prims.int ->
depth: Prims.nat
-> FStar.All.ALL Prims.unit | FStar.All.ALL | [] | [] | [
"Prims.string",
"FStar.ST.ref",
"Prims.int",
"Prims.unit",
"Z3.Base.z3",
"Z3TestGen.prog",
"Prims.list",
"Z3TestGen.arg_type",
"Prims.nat",
"Prims.eq2",
"Z3TestGen.count_args",
"Z3TestGen.witnesses_for",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Base.seq",
"FStar.Pervasives.Native.Mktuple2",
"Z3TestGen.print_diff_witness_as_c",
"Z3TestGen.mk_get_diff_test_witness",
"Prims.Nil",
"FStar.IO.print_string",
"FStar.Printf.sprintf"
] | [] | false | true | false | false | false | let do_diff_test_for
(out_dir: string)
(counter: ref int)
(cout: (string -> ML unit))
(z3: Z3.z3)
(prog: prog)
name1
name2
args
(nargs: nat{nargs == count_args args})
validator_name1
validator_name2
nbwitnesses
depth
=
| FStar.IO.print_string (Printf.sprintf ";; Witnesses that work with %s but not with %s\n" name1 name2
);
witnesses_for z3
name1
args
nargs
([
print_diff_witness_as_c out_dir cout validator_name1 validator_name2 args counter,
(fun _ -> mk_get_diff_test_witness name1 args name2)
])
nbwitnesses
depth | false |
|
Z3TestGen.fst | Z3TestGen.arg_type_of_typ | val arg_type_of_typ (t: T.typ) : Tot (option arg_type) | val arg_type_of_typ (t: T.typ) : Tot (option arg_type) | let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 13,
"end_line": 1004,
"start_col": 0,
"start_line": 989
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Target.typ -> FStar.Pervasives.Native.option Z3TestGen.arg_type | Prims.Tot | [
"total"
] | [] | [
"Target.typ",
"FStar.Pervasives.Native.Some",
"Z3TestGen.arg_type",
"Z3TestGen.ArgPointer",
"Ast.ident",
"Prims.list",
"FStar.Pervasives.either",
"Target.expr",
"Ast.range",
"Ast.comments",
"Ast.t_kind",
"Z3TestGen.ArgBool",
"Ast.maybe_as_integer_typ",
"Ast.integer_type",
"Z3TestGen.ArgInt",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option"
] | [] | false | false | false | true | false | let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
| match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app { v = { modul_name = None ; name = "PUINT8" } } _ _ -> Some ArgPointer
| T.T_app { v = { modul_name = None ; name = "Bool" } } _ _ -> Some ArgBool
| T.T_app i _ _ ->
(match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None)
| _ -> None | false |
Z3TestGen.fst | Z3TestGen.mk_get_negative_test_witness | val mk_get_negative_test_witness (name: string) (l: list arg_type) : string | val mk_get_negative_test_witness (name: string) (l: list arg_type) : string | let mk_get_negative_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= state-witness-input-size -1)) ; validator shall genuinely fail, we are not interested in positive cases followed by garbage
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 1509,
"start_col": 0,
"start_line": 1506
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree
let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n"
let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= (input-size state-witness) 0)) ; validator shall consume all input
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | name: Prims.string -> l: Prims.list Z3TestGen.arg_type -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type"
] | [] | false | false | false | true | false | let mk_get_negative_test_witness (name: string) (l: list arg_type) : string =
| "\n(assert (= state-witness-input-size -1)) ; validator shall genuinely fail, we are not interested in positive cases followed by garbage\n" | false |
Z3TestGen.fst | Z3TestGen.mk_get_witness | val mk_get_witness (name: string) (l: list arg_type) : string | val mk_get_witness (name: string) (l: list arg_type) : string | let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 25,
"end_line": 1387,
"start_col": 0,
"start_line": 1377
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | name: Prims.string -> l: Prims.list Z3TestGen.arg_type -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Printf.sprintf",
"Z3TestGen.mk_assert_args",
"Z3TestGen.mk_call_args"
] | [] | false | false | false | true | false | let mk_get_witness (name: string) (l: list arg_type) : string =
| Printf.sprintf "\n%s\n(define-fun state-witness () State (%s initial-state))\n(define-fun state-witness-input-size () Int (input-size state-witness))\n(declare-fun state-witness-size () Int)\n(assert (<= state-witness-size (choice-index state-witness)))\n(assert (>= state-witness-size (choice-index state-witness)))\n"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l) | false |
Z3TestGen.fst | Z3TestGen.parse_nlist_total_constant_size | val parse_nlist_total_constant_size (i: I.itype{Some? (itype_byte_size i)}) (size: I.expr)
: Tot (parser not_reading) | val parse_nlist_total_constant_size (i: I.itype{Some? (itype_byte_size i)}) (size: I.expr)
: Tot (parser not_reading) | let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
] | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 871,
"start_col": 0,
"start_line": 862
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | i: InterpreterTarget.itype{Some? (Z3TestGen.itype_byte_size i)} -> size: InterpreterTarget.expr
-> Z3TestGen.parser Z3TestGen.not_reading | Prims.Tot | [
"total"
] | [] | [
"InterpreterTarget.itype",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.pos",
"Z3TestGen.itype_byte_size",
"InterpreterTarget.expr",
"Z3TestGen.parse_not_readable_app'",
"Prims.Cons",
"Target.mk_expr",
"Target.Constant",
"Ast.Int",
"Ast.UInt8",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Prims.Nil",
"Z3TestGen.parser",
"Z3TestGen.not_reading"
] | [] | false | false | false | false | false | let parse_nlist_total_constant_size (i: I.itype{Some? (itype_byte_size i)}) (size: I.expr)
: Tot (parser not_reading) =
| parse_not_readable_app' "parse-nlist-total-constant-size"
[size; T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))))] | false |
Z3TestGen.fst | Z3TestGen.type_has_actions | val type_has_actions : _: InterpreterTarget.typ -> Prims.bool | let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 22,
"end_line": 928,
"start_col": 0,
"start_line": 906
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call } | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: InterpreterTarget.typ -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"InterpreterTarget.typ",
"InterpreterTarget.non_empty_string",
"InterpreterTarget.readable_dtyp",
"InterpreterTarget.lam",
"InterpreterTarget.action",
"InterpreterTarget.expr",
"InterpreterTarget.dtyp",
"Ast.ident",
"Prims.op_BarBar",
"Z3TestGen.type_has_actions",
"Prims.string",
"Prims.bool"
] | [
"recursion"
] | false | false | false | true | false | let rec type_has_actions =
| function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _ -> true
| I.T_false _ | I.T_denoted _ _ | I.T_refine _ _ _ | I.T_string _ _ _ -> false
| I.T_if_else _ t1 t2 | I.T_pair _ t1 t2 -> type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) -> type_has_actions t | false |
|
Z3TestGen.fst | Z3TestGen.arg_type_of_typ_with_prog | val arg_type_of_typ_with_prog (accu: prog) (t: T.typ) : Tot (option arg_type) (decreases t) | val arg_type_of_typ_with_prog (accu: prog) (t: T.typ) : Tot (option arg_type) (decreases t) | let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 7,
"end_line": 1072,
"start_col": 0,
"start_line": 1052
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | accu: Z3TestGen.prog -> t: Target.typ
-> Prims.Tot (FStar.Pervasives.Native.option Z3TestGen.arg_type) | Prims.Tot | [
"total",
""
] | [] | [
"Z3TestGen.prog",
"Target.typ",
"Z3TestGen.arg_type_of_typ",
"Z3TestGen.arg_type",
"FStar.Pervasives.Native.Some",
"Ast.ident",
"Ast.t_kind",
"Prims.list",
"FStar.Pervasives.either",
"Target.expr",
"FStar.List.Tot.Base.assoc",
"Prims.string",
"Z3TestGen.prog_def",
"Z3TestGen.ident_to_string",
"Z3TestGen.__proj__Mkprog_def__item__enum_base_type",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"Target.action",
"Z3TestGen.arg_type_of_typ_with_prog",
"Target.lam",
"Ast.comments"
] | [
"recursion"
] | false | false | false | true | false | let rec arg_type_of_typ_with_prog (accu: prog) (t: T.typ) : Tot (option arg_type) (decreases t) =
| match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
match t with
| T.T_app hd _ _ ->
(match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None)
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ -> arg_type_of_typ_with_prog accu base
| _ -> None | false |
Z3TestGen.fst | Z3TestGen.typ_depth | val typ_depth (t: I.typ) : GTot nat (decreases t) | val typ_depth (t: I.typ) : GTot nat (decreases t) | let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0 | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 8,
"end_line": 945,
"start_col": 0,
"start_line": 930
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: InterpreterTarget.typ -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial",
""
] | [] | [
"InterpreterTarget.typ",
"InterpreterTarget.expr",
"Prims.op_Addition",
"Z3TestGen.typ_depth",
"InterpreterTarget.non_empty_string",
"InterpreterTarget.readable_dtyp",
"Ast.ident",
"InterpreterTarget.lam",
"Prims.string",
"Prims.nat"
] | [
"recursion"
] | false | false | false | false | false | let rec typ_depth (t: I.typ) : GTot nat (decreases t) =
| match t with
| I.T_if_else _ t1 t2 -> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2 -> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t' -> 1 + typ_depth t'
| _ -> 0 | false |
Z3TestGen.fst | Z3TestGen.test_checker_c | val test_checker_c (modul validator_name: string) (params: list arg_type) : Tot string | val test_checker_c (modul validator_name: string) (params: list arg_type) : Tot string | let test_checker_c
(modul: string)
(validator_name: string)
(params: list arg_type)
: Tot string
=
let (nb_cmd_and_args, read_args, call_args_lhs, call_args_rhs) = List.Tot.fold_left test_exe_mk_arg (2, "", "", "") params in
let nb_cmd_and_args_s = string_of_int nb_cmd_and_args in
let nb_args_s = string_of_int (nb_cmd_and_args - 1) in
"
#include \""^modul^".h\"
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
"^test_error_handler^"
int main(int argc, char** argv) {
if (argc < "^nb_cmd_and_args_s^") {
printf(\"Wrong number of arguments, expected "^nb_args_s^", got %d\\n\", argc - 1);
return 3;
}
char * filename = argv[1];
"^read_args^"
int testfile = open(filename, O_RDONLY);
if (testfile == -1) {
printf(\"File %s does not exist\\n\", filename);
return 3;
}
struct stat statbuf;
if (fstat(testfile, &statbuf)) {
close(testfile);
printf(\"Cannot detect file size for %s\\n\", filename);
return 3;
}
off_t len = statbuf.st_size;
if (len > 4294967295) {
close(testfile);
printf(\"File is too large. EverParse/3D only supports data up to 4 GB\");
return 3;
}
uint8_t dummy = 42;
uint8_t * buf = &dummy; // for zero-sized files (mmap does not support zero-sized mappings)
void * vbuf = NULL;
if (len > 0) {
vbuf = mmap(NULL, len, PROT_READ, MAP_PRIVATE, testfile, 0);
if (vbuf == MAP_FAILED) {
close(testfile);
printf(\"Cannot read %ld bytes from %s\\n\", len, filename);
return 3;
};
buf = (uint8_t *) vbuf;
};
printf(\"Read %ld bytes from %s\\n\", len, filename);
uint8_t context = 0;
uint64_t result = "^validator_name^"("^call_args_lhs^"&context, &TestErrorHandler, buf, len, 0);
if (len > 0)
munmap(vbuf, len);
close(testfile);
if (EverParseIsError(result)) {
printf(\"Witness from %s REJECTED because validator failed\\n\", filename);
return 2;
};
if (result != (uint64_t) len) { // consistent with the postcondition of validate_with_action_t' (see also valid_length)
printf(\"Witness from %s REJECTED because validator only consumed %ld out of %ld bytes\\n\", filename, result, len);
return 1;
}
printf(\"Witness from %s ACCEPTED\\n\", filename);
return 0;
}
" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 1727,
"start_col": 0,
"start_line": 1654
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree
let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n"
let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= (input-size state-witness) 0)) ; validator shall consume all input
"
let mk_get_negative_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= state-witness-input-size -1)) ; validator shall genuinely fail, we are not interested in positive cases followed by garbage
"
let test_error_handler = "
static void TestErrorHandler (
const char *typename_s,
const char *fieldname,
const char *reason,
uint64_t error_code,
uint8_t *context,
EVERPARSE_INPUT_BUFFER input,
uint64_t start_pos
) {
(void) error_code;
(void) input;
if (*context) {
printf(\"Reached from position %ld: type name %s, field name %s\\n\", start_pos, typename_s, fieldname);
} else {
printf(\"Parsing failed at position %ld: type name %s, field name %s. Reason: %s\\n\", start_pos, typename_s, fieldname, reason);
*context = 1;
}
}
"
let do_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) (name1: string) (nbwitnesses: int) (depth: nat) (pos: bool) (neg: bool) : ML unit =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = (Some?.v def).args in
let modul, validator_name = module_and_validator_name name1 in
let nargs = count_args args in with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
let tasks =
begin
if pos
then [print_witness_as_c out_dir cout true validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
mk_get_positive_test_witness name1 args
))]
else []
end `List.Tot.append`
begin
if neg
then [print_witness_as_c out_dir cout false validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
mk_get_negative_test_witness name1 args
))]
else []
end
in
witnesses_for z3 name1 args nargs tasks nbwitnesses depth;
cout " return 0;
}
"
)
let mk_get_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string =
let call2 = mk_call_args name2 0 l in
Printf.sprintf
"
%s
(define-fun negative-state-witness () State (%s (mk-state initial-input-size 0 -1))) ; branch trace is ignored for the second parser
(assert (not (= (input-size negative-state-witness) 0))) ; test cases that do not consume everything are considered failing
(assert (>= (input-size negative-state-witness) -1)) ; do not record tests that artificially fail due to SMT2 encoding
"
(mk_get_positive_test_witness name1 l)
call2
let do_diff_test_for (out_dir: string) (counter: ref int) (cout: string -> ML unit) (z3: Z3.z3) (prog: prog) name1 name2 args (nargs: nat { nargs == count_args args }) validator_name1 validator_name2 nbwitnesses depth =
FStar.IO.print_string (Printf.sprintf ";; Witnesses that work with %s but not with %s\n" name1 name2);
witnesses_for z3 name1 args nargs ([print_diff_witness_as_c out_dir cout validator_name1 validator_name2 args counter, (fun _ -> mk_get_diff_test_witness name1 args name2)]) nbwitnesses depth
let do_diff_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) name1 name2 nbwitnesses depth =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_diff_test: parser %s not found" name1);
let args = (Some?.v def).args in
let def2 = List.assoc name2 prog in
if None? def2
then failwith (Printf.sprintf "do_diff_test: parser %s not found" name2);
if def2 <> def
then failwith (Printf.sprintf "do_diff_test: parsers %s and %s do not have the same arg types" name1 name2);
let nargs = count_args args in
let modul1, validator_name1 = module_and_validator_name name1 in
let modul2, validator_name2 = module_and_validator_name name2 in
with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul1;
cout ".h\"
#include \"";
cout modul2;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
do_diff_test_for out_dir counter cout z3 prog name1 name2 args nargs validator_name1 validator_name2 nbwitnesses depth;
do_diff_test_for out_dir counter cout z3 prog name2 name1 args nargs validator_name2 validator_name1 nbwitnesses depth;
cout " return 0;
}
"
)
let test_exe_mk_arg
(accu: (int & string & string & string))
(p: arg_type)
: Tot (int & string & string & string)
= let (cur_arg, read_args, call_args_lhs, call_args_rhs) = accu in
let cur_arg_s = string_of_int cur_arg in
let arg_var = "arg" ^ cur_arg_s in
let cur_arg' = cur_arg + 1 in
let read_args' = read_args ^
begin match p with
| ArgInt _ -> "
unsigned long long "^arg_var^" = strtoull(argv["^cur_arg_s^"], NULL, 0);
"
| ArgBool -> "
BOOLEAN "^arg_var^" = (strcmp(argv["^cur_arg_s^"], \"true\") == 0);
if (! ("^arg_var^" || strcmp(argv["^cur_arg_s^"], \"false\") == 0)) {
printf(\"Argument %d must be true or false, got %s\\n\", "^cur_arg_s^", argv["^cur_arg_s^"]);
return 1;
}
"
| _ -> "
void * "^arg_var^" = NULL;
"
end
in
let call_args_lhs' = call_args_lhs ^ arg_var ^ ", " in
let call_args_rhs' = call_args_lhs ^ ", " ^ arg_var in
(cur_arg', read_args', call_args_lhs', call_args_rhs') | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | modul: Prims.string -> validator_name: Prims.string -> params: Prims.list Z3TestGen.arg_type
-> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"Prims.int",
"Prims.op_Hat",
"Z3TestGen.test_error_handler",
"Prims.string_of_int",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple4",
"FStar.List.Tot.Base.fold_left",
"Z3TestGen.test_exe_mk_arg",
"FStar.Pervasives.Native.Mktuple4"
] | [] | false | false | false | true | false | let test_checker_c (modul validator_name: string) (params: list arg_type) : Tot string =
| let nb_cmd_and_args, read_args, call_args_lhs, call_args_rhs =
List.Tot.fold_left test_exe_mk_arg (2, "", "", "") params
in
let nb_cmd_and_args_s = string_of_int nb_cmd_and_args in
let nb_args_s = string_of_int (nb_cmd_and_args - 1) in
"\n#include \"" ^
modul ^
".h\"\n#include <fcntl.h>\n#include <sys/mman.h>\n#include <sys/stat.h>\n#include <stdint.h>\n#include <unistd.h>\n#include <stdlib.h>\n\n" ^
test_error_handler ^
"\n\nint main(int argc, char** argv) {\n if (argc < " ^
nb_cmd_and_args_s ^
") {\n printf(\"Wrong number of arguments, expected " ^
nb_args_s ^
", got %d\\n\", argc - 1);\n return 3;\n }\n char * filename = argv[1];\n" ^
read_args ^
"\n int testfile = open(filename, O_RDONLY);\n if (testfile == -1) {\n printf(\"File %s does not exist\\n\", filename);\n return 3;\n }\n struct stat statbuf;\n if (fstat(testfile, &statbuf)) {\n close(testfile);\n printf(\"Cannot detect file size for %s\\n\", filename);\n return 3;\n }\n off_t len = statbuf.st_size;\n if (len > 4294967295) {\n close(testfile);\n printf(\"File is too large. EverParse/3D only supports data up to 4 GB\");\n return 3;\n }\n uint8_t dummy = 42;\n uint8_t * buf = &dummy; // for zero-sized files (mmap does not support zero-sized mappings)\n void * vbuf = NULL;\n if (len > 0) {\n vbuf = mmap(NULL, len, PROT_READ, MAP_PRIVATE, testfile, 0);\n if (vbuf == MAP_FAILED) {\n close(testfile);\n printf(\"Cannot read %ld bytes from %s\\n\", len, filename);\n return 3;\n };\n buf = (uint8_t *) vbuf;\n };\n printf(\"Read %ld bytes from %s\\n\", len, filename);\n uint8_t context = 0;\n uint64_t result = " ^
validator_name ^
"(" ^
call_args_lhs ^
"&context, &TestErrorHandler, buf, len, 0);\n if (len > 0)\n munmap(vbuf, len);\n close(testfile);\n if (EverParseIsError(result)) {\n printf(\"Witness from %s REJECTED because validator failed\\n\", filename);\n return 2;\n };\n if (result != (uint64_t) len) { // consistent with the postcondition of validate_with_action_t' (see also valid_length)\n printf(\"Witness from %s REJECTED because validator only consumed %ld out of %ld bytes\\n\", filename, result, len);\n return 1;\n }\n printf(\"Witness from %s ACCEPTED\\n\", filename);\n return 0;\n}\n" | false |
Z3TestGen.fst | Z3TestGen.test_exe_mk_arg | val test_exe_mk_arg (accu: (int & string & string & string)) (p: arg_type)
: Tot (int & string & string & string) | val test_exe_mk_arg (accu: (int & string & string & string)) (p: arg_type)
: Tot (int & string & string & string) | let test_exe_mk_arg
(accu: (int & string & string & string))
(p: arg_type)
: Tot (int & string & string & string)
= let (cur_arg, read_args, call_args_lhs, call_args_rhs) = accu in
let cur_arg_s = string_of_int cur_arg in
let arg_var = "arg" ^ cur_arg_s in
let cur_arg' = cur_arg + 1 in
let read_args' = read_args ^
begin match p with
| ArgInt _ -> "
unsigned long long "^arg_var^" = strtoull(argv["^cur_arg_s^"], NULL, 0);
"
| ArgBool -> "
BOOLEAN "^arg_var^" = (strcmp(argv["^cur_arg_s^"], \"true\") == 0);
if (! ("^arg_var^" || strcmp(argv["^cur_arg_s^"], \"false\") == 0)) {
printf(\"Argument %d must be true or false, got %s\\n\", "^cur_arg_s^", argv["^cur_arg_s^"]);
return 1;
}
"
| _ -> "
void * "^arg_var^" = NULL;
"
end
in
let call_args_lhs' = call_args_lhs ^ arg_var ^ ", " in
let call_args_rhs' = call_args_lhs ^ ", " ^ arg_var in
(cur_arg', read_args', call_args_lhs', call_args_rhs') | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 56,
"end_line": 1652,
"start_col": 0,
"start_line": 1625
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree
let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n"
let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= (input-size state-witness) 0)) ; validator shall consume all input
"
let mk_get_negative_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= state-witness-input-size -1)) ; validator shall genuinely fail, we are not interested in positive cases followed by garbage
"
let test_error_handler = "
static void TestErrorHandler (
const char *typename_s,
const char *fieldname,
const char *reason,
uint64_t error_code,
uint8_t *context,
EVERPARSE_INPUT_BUFFER input,
uint64_t start_pos
) {
(void) error_code;
(void) input;
if (*context) {
printf(\"Reached from position %ld: type name %s, field name %s\\n\", start_pos, typename_s, fieldname);
} else {
printf(\"Parsing failed at position %ld: type name %s, field name %s. Reason: %s\\n\", start_pos, typename_s, fieldname, reason);
*context = 1;
}
}
"
let do_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) (name1: string) (nbwitnesses: int) (depth: nat) (pos: bool) (neg: bool) : ML unit =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = (Some?.v def).args in
let modul, validator_name = module_and_validator_name name1 in
let nargs = count_args args in with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
let tasks =
begin
if pos
then [print_witness_as_c out_dir cout true validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
mk_get_positive_test_witness name1 args
))]
else []
end `List.Tot.append`
begin
if neg
then [print_witness_as_c out_dir cout false validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
mk_get_negative_test_witness name1 args
))]
else []
end
in
witnesses_for z3 name1 args nargs tasks nbwitnesses depth;
cout " return 0;
}
"
)
let mk_get_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string =
let call2 = mk_call_args name2 0 l in
Printf.sprintf
"
%s
(define-fun negative-state-witness () State (%s (mk-state initial-input-size 0 -1))) ; branch trace is ignored for the second parser
(assert (not (= (input-size negative-state-witness) 0))) ; test cases that do not consume everything are considered failing
(assert (>= (input-size negative-state-witness) -1)) ; do not record tests that artificially fail due to SMT2 encoding
"
(mk_get_positive_test_witness name1 l)
call2
let do_diff_test_for (out_dir: string) (counter: ref int) (cout: string -> ML unit) (z3: Z3.z3) (prog: prog) name1 name2 args (nargs: nat { nargs == count_args args }) validator_name1 validator_name2 nbwitnesses depth =
FStar.IO.print_string (Printf.sprintf ";; Witnesses that work with %s but not with %s\n" name1 name2);
witnesses_for z3 name1 args nargs ([print_diff_witness_as_c out_dir cout validator_name1 validator_name2 args counter, (fun _ -> mk_get_diff_test_witness name1 args name2)]) nbwitnesses depth
let do_diff_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) name1 name2 nbwitnesses depth =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_diff_test: parser %s not found" name1);
let args = (Some?.v def).args in
let def2 = List.assoc name2 prog in
if None? def2
then failwith (Printf.sprintf "do_diff_test: parser %s not found" name2);
if def2 <> def
then failwith (Printf.sprintf "do_diff_test: parsers %s and %s do not have the same arg types" name1 name2);
let nargs = count_args args in
let modul1, validator_name1 = module_and_validator_name name1 in
let modul2, validator_name2 = module_and_validator_name name2 in
with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul1;
cout ".h\"
#include \"";
cout modul2;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
do_diff_test_for out_dir counter cout z3 prog name1 name2 args nargs validator_name1 validator_name2 nbwitnesses depth;
do_diff_test_for out_dir counter cout z3 prog name2 name1 args nargs validator_name2 validator_name1 nbwitnesses depth;
cout " return 0;
}
"
) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | accu: (((Prims.int * Prims.string) * Prims.string) * Prims.string) -> p: Z3TestGen.arg_type
-> ((Prims.int * Prims.string) * Prims.string) * Prims.string | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple4",
"Prims.int",
"Prims.string",
"Z3TestGen.arg_type",
"FStar.Pervasives.Native.Mktuple4",
"Prims.op_Hat",
"Ast.integer_type",
"Prims.op_Addition",
"Prims.string_of_int"
] | [] | false | false | false | true | false | let test_exe_mk_arg (accu: (int & string & string & string)) (p: arg_type)
: Tot (int & string & string & string) =
| let cur_arg, read_args, call_args_lhs, call_args_rhs = accu in
let cur_arg_s = string_of_int cur_arg in
let arg_var = "arg" ^ cur_arg_s in
let cur_arg' = cur_arg + 1 in
let read_args' =
read_args ^
(match p with
| ArgInt _ ->
"\n unsigned long long " ^ arg_var ^ " = strtoull(argv[" ^ cur_arg_s ^ "], NULL, 0);\n"
| ArgBool ->
"\n BOOLEAN " ^
arg_var ^
" = (strcmp(argv[" ^
cur_arg_s ^
"], \"true\") == 0);\n if (! (" ^
arg_var ^
" || strcmp(argv[" ^
cur_arg_s ^
"], \"false\") == 0)) {\n printf(\"Argument %d must be true or false, got %s\\n\", " ^
cur_arg_s ^ ", argv[" ^ cur_arg_s ^ "]);\n return 1;\n }\n"
| _ -> "\nvoid * " ^ arg_var ^ " = NULL;\n")
in
let call_args_lhs' = call_args_lhs ^ arg_var ^ ", " in
let call_args_rhs' = call_args_lhs ^ ", " ^ arg_var in
(cur_arg', read_args', call_args_lhs', call_args_rhs') | false |
Z3TestGen.fst | Z3TestGen.produce_decl | val produce_decl (out: (string -> ML unit)) (accu: prog) (a: I.decl) : ML prog | val produce_decl (out: (string -> ML unit)) (accu: prog) (a: I.decl) : ML prog | let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 41,
"end_line": 1090,
"start_col": 0,
"start_line": 1087
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
accu: Z3TestGen.prog ->
a: InterpreterTarget.decl
-> FStar.All.ML Z3TestGen.prog | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"Z3TestGen.prog",
"InterpreterTarget.decl",
"InterpreterTarget.not_type_decl",
"Z3TestGen.produce_not_type_decl",
"InterpreterTarget.type_decl",
"Z3TestGen.produce_type_decl"
] | [] | false | true | false | false | false | let produce_decl (out: (string -> ML unit)) (accu: prog) (a: I.decl) : ML prog =
| match a with
| Inl a ->
produce_not_type_decl a out;
accu
| Inr a -> produce_type_decl out accu a | false |
Z3TestGen.fst | Z3TestGen.mk_witness_call | val mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) | val mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) | let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 35,
"end_line": 1307,
"start_col": 0,
"start_line": 1303
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | accu: Prims.string -> l: Prims.list Z3TestGen.arg_type -> args: Prims.list Prims.string
-> Prims.Tot Prims.string | Prims.Tot | [
"total",
""
] | [] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Pervasives.Native.Mktuple2",
"Z3TestGen.mk_witness_call",
"FStar.Printf.sprintf",
"FStar.Pervasives.Native.tuple2"
] | [
"recursion"
] | false | false | false | true | false | let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string)
: Tot string (decreases l) =
| match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu | false |
Z3TestGen.fst | Z3TestGen.parse_typ | val parse_typ (t: I.typ)
: Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t)) | val parse_typ (t: I.typ)
: Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t)) | let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 84,
"end_line": 982,
"start_col": 0,
"start_line": 947
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0 | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: InterpreterTarget.typ -> Prims.Pure (Z3TestGen.parser Z3TestGen.not_reading) | Prims.Pure | [
""
] | [
"parse_typ",
"parse_ifthenelse"
] | [
"InterpreterTarget.typ",
"InterpreterTarget.non_empty_string",
"Z3TestGen.parse_false",
"InterpreterTarget.dtyp",
"Z3TestGen.parse_denoted",
"Z3TestGen.parse_pair",
"Z3TestGen.parse_typ",
"InterpreterTarget.readable_dtyp",
"Ast.ident",
"Z3TestGen.parse_dep_pair",
"Z3TestGen.parse_readable_dtyp",
"InterpreterTarget.expr",
"Z3TestGen.parse_refine",
"Prims.unit",
"Z3TestGen.mk_expr",
"Prims.string",
"Z3TestGen.parse_dep_pair_with_refinement",
"Z3TestGen.parse_ifthenelse",
"Z3TestGen.parse_at_most",
"Z3TestGen.parse_exact",
"Z3TestGen.parse_string",
"InterpreterTarget.itype",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.pos",
"Z3TestGen.itype_byte_size",
"Z3TestGen.parse_nlist_total_constant_size",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Prims.bool",
"Z3TestGen.parse_nlist",
"Prims.eq2",
"Z3TestGen.type_has_actions",
"Prims.l_True"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec parse_typ (t: I.typ)
: Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t)) =
| match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) ->
parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) ->
parse_dep_pair_with_refinement (parse_readable_dtyp base)
lam_cond
(fun _ -> mk_expr cond)
lam_k
(parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator ->
parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if
match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else parse_nlist (fun _ -> mk_expr size) (parse_typ body) | false |
Z3TestGen.fst | Z3TestGen.mk_args_as_file_name | val mk_args_as_file_name (accu: string) (l: list string) : Tot string (decreases l) | val mk_args_as_file_name (accu: string) (l: list string) : Tot string (decreases l) | let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 53,
"end_line": 1255,
"start_col": 0,
"start_line": 1251
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | accu: Prims.string -> l: Prims.list Prims.string -> Prims.Tot Prims.string | Prims.Tot | [
"total",
""
] | [] | [
"Prims.string",
"Prims.list",
"Z3TestGen.mk_args_as_file_name",
"Prims.op_Hat"
] | [
"recursion"
] | false | false | false | true | false | let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string (decreases l) =
| match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q | false |
Z3TestGen.fst | Z3TestGen.mk_get_diff_test_witness | val mk_get_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string | val mk_get_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string | let mk_get_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string =
let call2 = mk_call_args name2 0 l in
Printf.sprintf
"
%s
(define-fun negative-state-witness () State (%s (mk-state initial-input-size 0 -1))) ; branch trace is ignored for the second parser
(assert (not (= (input-size negative-state-witness) 0))) ; test cases that do not consume everything are considered failing
(assert (>= (input-size negative-state-witness) -1)) ; do not record tests that artificially fail due to SMT2 encoding
"
(mk_get_positive_test_witness name1 l)
call2 | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 7,
"end_line": 1584,
"start_col": 0,
"start_line": 1574
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree
let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n"
let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= (input-size state-witness) 0)) ; validator shall consume all input
"
let mk_get_negative_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= state-witness-input-size -1)) ; validator shall genuinely fail, we are not interested in positive cases followed by garbage
"
let test_error_handler = "
static void TestErrorHandler (
const char *typename_s,
const char *fieldname,
const char *reason,
uint64_t error_code,
uint8_t *context,
EVERPARSE_INPUT_BUFFER input,
uint64_t start_pos
) {
(void) error_code;
(void) input;
if (*context) {
printf(\"Reached from position %ld: type name %s, field name %s\\n\", start_pos, typename_s, fieldname);
} else {
printf(\"Parsing failed at position %ld: type name %s, field name %s. Reason: %s\\n\", start_pos, typename_s, fieldname, reason);
*context = 1;
}
}
"
let do_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) (name1: string) (nbwitnesses: int) (depth: nat) (pos: bool) (neg: bool) : ML unit =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = (Some?.v def).args in
let modul, validator_name = module_and_validator_name name1 in
let nargs = count_args args in with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
let tasks =
begin
if pos
then [print_witness_as_c out_dir cout true validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
mk_get_positive_test_witness name1 args
))]
else []
end `List.Tot.append`
begin
if neg
then [print_witness_as_c out_dir cout false validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
mk_get_negative_test_witness name1 args
))]
else []
end
in
witnesses_for z3 name1 args nargs tasks nbwitnesses depth;
cout " return 0;
}
"
) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | name1: Prims.string -> l: Prims.list Z3TestGen.arg_type -> name2: Prims.string -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Printf.sprintf",
"Z3TestGen.mk_get_positive_test_witness",
"Z3TestGen.mk_call_args"
] | [] | false | false | false | true | false | let mk_get_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string =
| let call2 = mk_call_args name2 0 l in
Printf.sprintf "\n%s\n(define-fun negative-state-witness () State (%s (mk-state initial-input-size 0 -1))) ; branch trace is ignored for the second parser\n(assert (not (= (input-size negative-state-witness) 0))) ; test cases that do not consume everything are considered failing\n(assert (>= (input-size negative-state-witness) -1)) ; do not record tests that artificially fail due to SMT2 encoding\n"
(mk_get_positive_test_witness name1 l)
call2 | false |
Z3TestGen.fst | Z3TestGen.mk_call_args | val mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) | val mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) | let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 72,
"end_line": 1368,
"start_col": 0,
"start_line": 1364
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | accu: Prims.string -> i: Prims.nat -> l: Prims.list Z3TestGen.arg_type -> Prims.Tot Prims.string | Prims.Tot | [
"total",
""
] | [] | [
"Prims.string",
"Prims.nat",
"Prims.list",
"Z3TestGen.arg_type",
"Z3TestGen.mk_call_args",
"FStar.Printf.sprintf",
"Prims.op_Addition"
] | [
"recursion"
] | false | false | false | true | false | let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
| match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q | false |
Z3TestGen.fst | Z3TestGen.print_witness_as_c_aux | val print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int{len == Seq.length witness})
: ML unit | val print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int{len == Seq.length witness})
: ML unit | let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};" | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 10,
"end_line": 1232,
"start_col": 0,
"start_line": 1217
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
witness: FStar.Seq.Base.seq Prims.int ->
len: Prims.int{len == FStar.Seq.Base.length witness}
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.eq2",
"FStar.Seq.Base.length",
"FStar.Seq.Base.seq_to_list",
"Prims.list",
"FStar.List.iter",
"Prims.string_of_int"
] | [] | false | true | false | false | false | let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int{len == Seq.length witness})
: ML unit =
| out " uint8_t witness[";
out (string_of_int len);
out "] = {";
(match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i ->
out ", ";
out (string_of_int i))
q);
out "};" | false |
Z3TestGen.fst | Z3TestGen.mk_output_filename | val mk_output_filename (counter: ref int) (out_dir validator_name: string) (args: list string)
: ML string | val mk_output_filename (counter: ref int) (out_dir validator_name: string) (args: list string)
: ML string | let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat") | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 110,
"end_line": 1265,
"start_col": 0,
"start_line": 1257
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
counter: FStar.ST.ref Prims.int ->
out_dir: Prims.string ->
validator_name: Prims.string ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.string | FStar.All.ML | [
"ml"
] | [] | [
"FStar.ST.ref",
"Prims.int",
"Prims.string",
"Prims.list",
"OS.concat",
"Prims.op_Hat",
"Z3TestGen.mk_args_as_file_name",
"Prims.string_of_int",
"Prims.unit",
"FStar.ST.op_Colon_Equals",
"FStar.Heap.trivial_preorder",
"Prims.op_Addition",
"FStar.ST.op_Bang"
] | [] | false | true | false | false | false | let mk_output_filename (counter: ref int) (out_dir validator_name: string) (args: list string)
: ML string =
| let i = !counter in
counter := i + 1;
OS.concat out_dir
(mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat") | false |
Z3TestGen.fst | Z3TestGen.produce_type_decl | val produce_type_decl (out: (string -> ML unit)) (accu: prog) (a: I.type_decl) : ML prog | val produce_type_decl (out: (string -> ML unit)) (accu: prog) (a: I.type_decl) : ML prog | let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 12,
"end_line": 1085,
"start_col": 0,
"start_line": 1074
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
accu: Z3TestGen.prog ->
a: InterpreterTarget.type_decl
-> FStar.All.ML Z3TestGen.prog | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"Z3TestGen.prog",
"InterpreterTarget.type_decl",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"Z3TestGen.prog_def",
"FStar.Pervasives.Native.Mktuple2",
"Z3TestGen.Mkprog_def",
"InterpreterTarget.__proj__Mktype_decl__item__enum_typ",
"Target.typ",
"Prims.b2t",
"Target.uu___is_T_refine",
"Z3TestGen.arg_type_of_typ_with_prog",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"Z3TestGen.arg_type",
"Prims.list",
"FStar.List.map",
"Ast.with_meta_t",
"Ast.ident'",
"FStar.All.failwith",
"FStar.Printf.sprintf",
"Z3TestGen.ident_to_string",
"Target.__proj__Mktypedef_name__item__td_params",
"InterpreterTarget.__proj__Mktype_decl__item__name",
"Z3TestGen.not_reading",
"Z3TestGen.parse_typ",
"InterpreterTarget.__proj__Mktype_decl__item__typ",
"Z3TestGen.type_has_actions",
"Prims.bool",
"Target.__proj__Mktypedef_name__item__td_name",
"Z3TestGen.binders",
"Z3TestGen.binders_of_params"
] | [] | false | true | false | false | false | let produce_type_decl (out: (string -> ML unit)) (accu: prog) (a: I.type_decl) : ML prog =
| let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ
then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name,
{
args
=
List.map (fun (i, ty) ->
match arg_type_of_typ_with_prog accu ty with
| Some t -> t
| None ->
failwith (Printf.sprintf "Parser %s has unsupported argument type for %s"
name
(ident_to_string i)))
a.name.td_params;
enum_base_type
=
match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
}) ::
accu | false |
Z3TestGen.fst | Z3TestGen.read_witness_args | val read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) | val read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) | let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 1139,
"start_col": 0,
"start_line": 1131
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | z3: Z3.Base.z3 -> accu: Prims.list Prims.string -> n: Prims.nat
-> FStar.All.ML (Prims.list Prims.string) | FStar.All.ML | [
"ml"
] | [] | [
"Z3.Base.z3",
"Prims.list",
"Prims.string",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Z3TestGen.read_witness_args",
"Prims.Cons",
"Lisp.read_any_from",
"Z3.Base.__proj__Mkz3__item__from_z3",
"FStar.Printf.sprintf",
"Prims.unit",
"Z3.Base.__proj__Mkz3__item__to_z3",
"Prims.op_Subtraction"
] | [
"recursion"
] | false | true | false | false | false | let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
| if n = 0
then accu
else
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n' | false |
Z3TestGen.fst | Z3TestGen.produce_not_type_decl | val produce_not_type_decl (a: I.not_type_decl) (out: (string -> ML unit)) : ML unit | val produce_not_type_decl (a: I.not_type_decl) (out: (string -> ML unit)) : ML unit | let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> () | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 7,
"end_line": 1043,
"start_col": 0,
"start_line": 1033
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body)) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: InterpreterTarget.not_type_decl -> out: (_: Prims.string -> FStar.All.ML Prims.unit)
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"InterpreterTarget.not_type_decl",
"Prims.string",
"Prims.unit",
"FStar.Pervasives.Native.fst",
"Target.decl'",
"Target.decl_attributes",
"Ast.ident",
"Prims.list",
"Target.param",
"Target.typ",
"Target.expr",
"Z3TestGen.produce_definition",
"Target.assumption",
"FStar.All.failwith",
"Ast.out_typ",
"Target.output_expr",
"Prims.bool"
] | [] | false | true | false | false | false | let produce_not_type_decl (a: I.not_type_decl) (out: (string -> ML unit)) : ML unit =
| match fst a with
| T.Definition (i, param, typ, body) -> produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _ -> () | false |
Z3TestGen.fst | Z3TestGen.mk_choose_conj | val mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat)
: Tot string (decreases (if i >= Seq.length witness then 0 else Seq.length witness - i)) | val mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat)
: Tot string (decreases (if i >= Seq.length witness then 0 else Seq.length witness - i)) | let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 129,
"end_line": 1320,
"start_col": 0,
"start_line": 1316
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | witness: FStar.Seq.Base.seq Prims.int -> accu: Prims.string -> i: Prims.nat
-> Prims.Tot Prims.string | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.string",
"Prims.nat",
"Prims.op_GreaterThanOrEqual",
"FStar.Seq.Base.length",
"Prims.bool",
"Z3TestGen.mk_choose_conj",
"Prims.op_Hat",
"Prims.string_of_int",
"FStar.Seq.Base.index",
"Prims.op_Addition"
] | [
"recursion"
] | false | false | false | true | false | let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat)
: Tot string (decreases (if i >= Seq.length witness then 0 else Seq.length witness - i)) =
| if i >= Seq.length witness
then accu
else
mk_choose_conj witness
("(and (= (choose " ^
string_of_int i ^ ") " ^ string_of_int (Seq.index witness i) ^ ") " ^ accu ^ ")")
(i + 1) | false |
LowParse.Spec.VLData.fsti | LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd_bw_chain | val serialize_bounded_vldata_strong_upd_bw_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx' i' s'))) | val serialize_bounded_vldata_strong_upd_bw_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx' i' s'))) | let serialize_bounded_vldata_strong_upd_bw_chain
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
parse_bounded_vldata_strong_pred min max s y /\ (
let y : parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx' i' s'
)))
= serialize_bounded_vldata_strong_upd_chain min max s x y (Seq.length (serialize s x) - i' - Seq.length s') s' | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 110,
"end_line": 799,
"start_col": 0,
"start_line": 773
} | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
)
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == Seq.length b
)))) =
let (Some (len, consumed1)) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b
let serialize_vldata_gen_correct
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) (Seq.append b1 b2) in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == sz + Seq.length b2
)))) =
seq_slice_append_l b1 b2;
seq_slice_append_r b1 b2;
serialize_vldata_gen_correct_aux sz f p (Seq.append b1 b2) b1 b2
let serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted == Some (input, Seq.length formatted))
= let sz = l in
let sp = serialize s input in
let nlen = Seq.length sp in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
M.pow2_le_compat (FStar.Mul.op_Star 8 sz) (FStar.Mul.op_Star 8 (log256' max));
assert (U32.v len < pow2 (FStar.Mul.op_Star 8 sz));
let (len: bounded_integer sz) = len in
let slen = serialize (serialize_bounded_integer sz) len in
assert (Seq.length slen == sz);
let pslen = parse (parse_bounded_integer sz) slen in
assert (Some? pslen);
let (Some (len', consumed_len')) = pslen in
assert (len == len');
assert (in_bounds min max len' == true);
assert (Seq.length sp == U32.v len);
let psp = parse p sp in
assert (Some? psp);
let (Some (_, consumed_p)) = psp in
assert ((consumed_p <: nat) == Seq.length sp);
serialize_vldata_gen_correct sz (in_bounds min max) p
slen
sp
;
()
let serialize_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s))
= Classical.forall_intro (serialize_bounded_vldata_strong_correct min max l s);
serialize_bounded_vldata_strong_aux min max l s
let serialize_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong min max s))
= serialize_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_precond
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(k: parser_kind)
: GTot bool
= match k.parser_kind_high with
| None -> false
| Some max' -> min <= k.parser_kind_low && max' <= max
let serialize_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: Lemma
( let Some (_, consumed) = parse p (serialize s x) in
let y = serialize_bounded_vldata_strong_aux min max (log256' max) s (x <: parse_bounded_vldata_strong_t min max s) in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y))
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_strong_correct min max (log256' max) s x;
()
let serialize_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: GTot (y: bytes { parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y) } )
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_correct min max s x;
serialize_bounded_vldata_strong_aux min max (log256' max) s x
let serialize_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
: Tot (serializer (parse_bounded_vldata min max p))
= serialize_bounded_vldata' min max s
let serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy
))
= let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let sy = serialize s y in
let sy' = serialize (serialize_bounded_vldata_strong min max s) y in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
assert (lm + Seq.length sy == Seq.length sx');
seq_upd_seq_right sx' sy;
Seq.lemma_split sx' lm;
Seq.lemma_split sy' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
Seq.lemma_append_inj (Seq.slice sy' 0 lm) (Seq.slice sy' lm (Seq.length sy')) sz sy;
assert (sy' `Seq.equal` seq_upd_seq sx' lm sy)
let serialize_bounded_vldata_strong_upd_bw
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx 0 sy
))
= serialize_bounded_vldata_strong_upd min max s x y
let serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
parse_bounded_vldata_strong_pred min max s y /\ (
let y : parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s'
)))
= serialize_bounded_vldata_strong_upd min max s x y;
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
seq_upd_seq_right_to_left sx' lm sx i' s';
Seq.lemma_split sx' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
seq_upd_seq_seq_upd_seq_slice sx' lm (Seq.length sx') i' s'
#reset-options "--z3refresh --z3rlimit 32 --z3cliopt smt.arith.nl=false" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
s: LowParse.Spec.Base.serializer p ->
x: LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s ->
y: t ->
i': Prims.nat ->
s': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
(let sx = LowParse.Spec.Base.serialize s x in
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx /\
LowParse.Spec.Base.serialize s y == LowParse.Spec.Base.seq_upd_bw_seq sx i' s'))
(ensures
LowParse.Spec.VLData.parse_bounded_vldata_strong_pred min max s y /\
(let y = y in
let sx' =
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
x
in
let lm = LowParse.Spec.BoundedInt.log256' max in
lm + FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) == FStar.Seq.Base.length sx' /\
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx' /\
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
y ==
LowParse.Spec.Base.seq_upd_bw_seq sx' i' s')) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Bytes.bytes",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd_chain",
"Prims.op_Subtraction",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"Prims.unit",
"Prims.op_Addition",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowParse.Spec.Base.seq_upd_bw_seq",
"Prims.squash",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"Prims.int",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.VLData.parse_bounded_vldata_strong",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong",
"LowParse.Spec.BoundedInt.integer_size",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let serialize_bounded_vldata_strong_upd_bw_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx' i' s'))) =
| serialize_bounded_vldata_strong_upd_chain min
max
s
x
y
(Seq.length (serialize s x) - i' - Seq.length s')
s' | false |
Z3TestGen.fst | Z3TestGen.with_option_out_file | val with_option_out_file (#a: Type) (name: option string)
: Tot (body: ((string -> ML unit) -> ML a) -> ML a) | val with_option_out_file (#a: Type) (name: option string)
: Tot (body: ((string -> ML unit) -> ML a) -> ML a) | let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ())) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 1113,
"start_col": 0,
"start_line": 1107
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
name: FStar.Pervasives.Native.option Prims.string ->
body: (_: (_: Prims.string -> FStar.All.ML Prims.unit) -> FStar.All.ML a)
-> FStar.All.ML a | FStar.All.ML | [
"ml"
] | [] | [
"FStar.Pervasives.Native.option",
"Prims.string",
"Z3TestGen.with_out_file",
"Prims.unit"
] | [] | false | true | false | false | false | let with_option_out_file (#a: Type) (name: option string)
: Tot (body: ((string -> ML unit) -> ML a) -> ML a) =
| match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ())) | false |
Z3TestGen.fst | Z3TestGen.mk_arg_conj | val mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) | val mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) | let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 78,
"end_line": 1326,
"start_col": 0,
"start_line": 1322
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | accu: Prims.string -> i: Prims.nat -> l: Prims.list Prims.string -> Prims.Tot Prims.string | Prims.Tot | [
"total",
""
] | [] | [
"Prims.string",
"Prims.nat",
"Prims.list",
"Z3TestGen.mk_arg_conj",
"FStar.Printf.sprintf",
"Prims.op_Addition"
] | [
"recursion"
] | false | false | false | true | false | let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
| match l with
| [] -> accu
| arg :: q -> mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q | false |
Z3TestGen.fst | Z3TestGen.print_diff_witness_as_c | val print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1 validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit | val print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1 validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit | let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1296,
"start_col": 0,
"start_line": 1282
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
) | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out_dir: Prims.string ->
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
validator_name1: Prims.string ->
validator_name2: Prims.string ->
arg_types: Prims.list Z3TestGen.arg_type ->
counter: FStar.ST.ref Prims.int ->
witness: FStar.Seq.Base.seq Prims.int ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.ST.ref",
"Prims.int",
"FStar.Seq.Base.seq",
"Z3TestGen.print_witness_as_c_gen",
"Prims.eq2",
"FStar.Seq.Base.length",
"Z3TestGen.print_witness_call_as_c",
"OS.write_witness_to_file",
"FStar.Seq.Base.seq_to_list",
"Z3TestGen.mk_output_filename",
"Prims.op_Hat"
] | [] | false | true | false | false | false | let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1 validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit =
| OS.write_witness_to_file (Seq.seq_to_list witness)
(mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out
witness
(fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args) | false |
Z3TestGen.fst | Z3TestGen.print_witness_as_c | val print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit | val print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit | let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1280,
"start_col": 0,
"start_line": 1267
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat") | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out_dir: Prims.string ->
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
positive: Prims.bool ->
validator_name: Prims.string ->
arg_types: Prims.list Z3TestGen.arg_type ->
counter: FStar.ST.ref Prims.int ->
witness: FStar.Seq.Base.seq Prims.int ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Prims.unit",
"Prims.bool",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.ST.ref",
"Prims.int",
"FStar.Seq.Base.seq",
"Z3TestGen.print_witness_as_c_gen",
"Prims.eq2",
"FStar.Seq.Base.length",
"Z3TestGen.print_witness_call_as_c",
"OS.write_witness_to_file",
"FStar.Seq.Base.seq_to_list",
"Z3TestGen.mk_output_filename",
"Prims.op_Hat"
] | [] | false | true | false | false | false | let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit =
| OS.write_witness_to_file (Seq.seq_to_list witness)
(mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out
witness
(fun len -> print_witness_call_as_c out positive validator_name arg_types len args) | false |
Z3TestGen.fst | Z3TestGen.parse_ifthenelse | val parse_ifthenelse (cond: I.expr) (tthen telse: I.typ)
: Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse)) | val parse_ifthenelse (cond: I.expr) (tthen telse: I.typ)
: Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse)) | let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 84,
"end_line": 982,
"start_col": 0,
"start_line": 947
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0 | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | cond: InterpreterTarget.expr -> tthen: InterpreterTarget.typ -> telse: InterpreterTarget.typ
-> Prims.Pure (_: Prims.int -> Z3TestGen.parser Z3TestGen.not_reading) | Prims.Pure | [
""
] | [
"parse_typ",
"parse_ifthenelse"
] | [
"InterpreterTarget.expr",
"InterpreterTarget.typ",
"Z3TestGen.parse_ifthenelse_cons",
"Prims.unit",
"Z3TestGen.mk_expr",
"Prims.string",
"Z3TestGen.parse_typ",
"Z3TestGen.parse_ifthenelse",
"Z3TestGen.parse_ifthenelse_nil",
"Prims.int",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"Z3TestGen.type_has_actions",
"Prims.l_True"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec parse_ifthenelse (cond: I.expr) (tthen telse: I.typ)
: Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse)) =
| match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond)
(parse_typ tthen)
(parse_ifthenelse cond2 tthen2 telse2)
| _ -> parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse) | false |
Z3TestGen.fst | Z3TestGen.mk_assert_args | val mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) | val mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) | let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 186,
"end_line": 1375,
"start_col": 0,
"start_line": 1370
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | accu: Prims.string -> i: Prims.nat -> l: Prims.list Z3TestGen.arg_type -> Prims.Tot Prims.string | Prims.Tot | [
"total",
""
] | [] | [
"Prims.string",
"Prims.nat",
"Prims.list",
"Z3TestGen.arg_type",
"Z3TestGen.mk_assert_args",
"FStar.Printf.sprintf",
"Prims.op_Addition",
"Ast.integer_type",
"Prims.pow2",
"Z3TestGen.integer_type_bit_size"
] | [
"recursion"
] | false | false | false | true | false | let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
| match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q ->
mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q ->
mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n"
accu
i
i
i
(pow2 (integer_type_bit_size it)))
(i + 1)
q | false |
Z3TestGen.fst | Z3TestGen.enumerate_branch_traces' | val enumerate_branch_traces' (z3: Z3.z3) (max_depth cur_depth: nat) (branch_trace: string)
: ML (list branch_trace_node) | val enumerate_branch_traces' (z3: Z3.z3) (max_depth cur_depth: nat) (branch_trace: string)
: ML (list branch_trace_node) | let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 1454,
"start_col": 0,
"start_line": 1396
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | z3: Z3.Base.z3 -> max_depth: Prims.nat -> cur_depth: Prims.nat -> branch_trace: Prims.string
-> FStar.All.ML (Prims.list Z3TestGen.branch_trace_node) | FStar.All.ML | [
"ml"
] | [] | [
"Z3.Base.z3",
"Prims.nat",
"Prims.string",
"Prims.op_Equality",
"Prims.Nil",
"Z3TestGen.branch_trace_node",
"Prims.list",
"Prims.bool",
"Prims.int",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Addition",
"Prims.unit",
"Z3.Base.__proj__Mkz3__item__to_z3",
"FStar.IO.print_string",
"Prims.Cons",
"Z3TestGen.Node",
"Z3TestGen.enumerate_branch_traces'",
"FStar.List.Tot.Base.rev",
"Z3.Base.__proj__Mkz3__item__from_z3",
"Z3TestGen.assert_valid_state",
"FStar.Printf.sprintf",
"Prims.op_Hat",
"Prims.string_of_int"
] | [
"recursion"
] | false | true | false | false | false | let rec enumerate_branch_traces' (z3: Z3.z3) (max_depth cur_depth: nat) (branch_trace: string)
: ML (list branch_trace_node) =
| if max_depth = cur_depth
then []
else
(z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n"
branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then
(FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1))
else
if status = "sat"
then
(FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n"
;
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then
(FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1))
else
(FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu))
else
(FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu)
in
aux [] 0
else
(FStar.IO.print_string "Cannot take further branches under this case\n";
[])) | false |
Z3TestGen.fst | Z3TestGen.do_diff_test | val do_diff_test : out_dir: Prims.string ->
out_file: FStar.Pervasives.Native.option Prims.string ->
z3: Z3.Base.z3 ->
prog: Z3TestGen.prog ->
name1: Prims.string ->
name2: Prims.string ->
nbwitnesses: Prims.int ->
depth: Prims.nat
-> FStar.All.ALL Prims.unit | let do_diff_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) name1 name2 nbwitnesses depth =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_diff_test: parser %s not found" name1);
let args = (Some?.v def).args in
let def2 = List.assoc name2 prog in
if None? def2
then failwith (Printf.sprintf "do_diff_test: parser %s not found" name2);
if def2 <> def
then failwith (Printf.sprintf "do_diff_test: parsers %s and %s do not have the same arg types" name1 name2);
let nargs = count_args args in
let modul1, validator_name1 = module_and_validator_name name1 in
let modul2, validator_name2 = module_and_validator_name name2 in
with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul1;
cout ".h\"
#include \"";
cout modul2;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
do_diff_test_for out_dir counter cout z3 prog name1 name2 args nargs validator_name1 validator_name2 nbwitnesses depth;
do_diff_test_for out_dir counter cout z3 prog name2 name1 args nargs validator_name2 validator_name1 nbwitnesses depth;
cout " return 0;
}
"
) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 1623,
"start_col": 0,
"start_line": 1590
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree
let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n"
let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= (input-size state-witness) 0)) ; validator shall consume all input
"
let mk_get_negative_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= state-witness-input-size -1)) ; validator shall genuinely fail, we are not interested in positive cases followed by garbage
"
let test_error_handler = "
static void TestErrorHandler (
const char *typename_s,
const char *fieldname,
const char *reason,
uint64_t error_code,
uint8_t *context,
EVERPARSE_INPUT_BUFFER input,
uint64_t start_pos
) {
(void) error_code;
(void) input;
if (*context) {
printf(\"Reached from position %ld: type name %s, field name %s\\n\", start_pos, typename_s, fieldname);
} else {
printf(\"Parsing failed at position %ld: type name %s, field name %s. Reason: %s\\n\", start_pos, typename_s, fieldname, reason);
*context = 1;
}
}
"
let do_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) (name1: string) (nbwitnesses: int) (depth: nat) (pos: bool) (neg: bool) : ML unit =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = (Some?.v def).args in
let modul, validator_name = module_and_validator_name name1 in
let nargs = count_args args in with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
let tasks =
begin
if pos
then [print_witness_as_c out_dir cout true validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
mk_get_positive_test_witness name1 args
))]
else []
end `List.Tot.append`
begin
if neg
then [print_witness_as_c out_dir cout false validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
mk_get_negative_test_witness name1 args
))]
else []
end
in
witnesses_for z3 name1 args nargs tasks nbwitnesses depth;
cout " return 0;
}
"
)
let mk_get_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string =
let call2 = mk_call_args name2 0 l in
Printf.sprintf
"
%s
(define-fun negative-state-witness () State (%s (mk-state initial-input-size 0 -1))) ; branch trace is ignored for the second parser
(assert (not (= (input-size negative-state-witness) 0))) ; test cases that do not consume everything are considered failing
(assert (>= (input-size negative-state-witness) -1)) ; do not record tests that artificially fail due to SMT2 encoding
"
(mk_get_positive_test_witness name1 l)
call2
let do_diff_test_for (out_dir: string) (counter: ref int) (cout: string -> ML unit) (z3: Z3.z3) (prog: prog) name1 name2 args (nargs: nat { nargs == count_args args }) validator_name1 validator_name2 nbwitnesses depth =
FStar.IO.print_string (Printf.sprintf ";; Witnesses that work with %s but not with %s\n" name1 name2);
witnesses_for z3 name1 args nargs ([print_diff_witness_as_c out_dir cout validator_name1 validator_name2 args counter, (fun _ -> mk_get_diff_test_witness name1 args name2)]) nbwitnesses depth | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out_dir: Prims.string ->
out_file: FStar.Pervasives.Native.option Prims.string ->
z3: Z3.Base.z3 ->
prog: Z3TestGen.prog ->
name1: Prims.string ->
name2: Prims.string ->
nbwitnesses: Prims.int ->
depth: Prims.nat
-> FStar.All.ALL Prims.unit | FStar.All.ALL | [] | [] | [
"Prims.string",
"FStar.Pervasives.Native.option",
"Z3.Base.z3",
"Z3TestGen.prog",
"Prims.int",
"Prims.nat",
"Z3TestGen.with_option_out_file",
"Prims.unit",
"Z3TestGen.do_diff_test_for",
"FStar.ST.mref",
"FStar.Heap.trivial_preorder",
"FStar.ST.alloc",
"Z3TestGen.test_error_handler",
"FStar.Pervasives.Native.tuple2",
"Z3TestGen.module_and_validator_name",
"Z3TestGen.count_args",
"Prims.op_disEquality",
"Z3TestGen.prog_def",
"FStar.All.failwith",
"FStar.Printf.sprintf",
"Prims.bool",
"FStar.Pervasives.Native.uu___is_None",
"FStar.List.Tot.Base.assoc",
"Prims.list",
"Z3TestGen.arg_type",
"Z3TestGen.__proj__Mkprog_def__item__args",
"FStar.Pervasives.Native.__proj__Some__item__v"
] | [] | false | true | false | false | false | let do_diff_test
(out_dir: string)
(out_file: option string)
(z3: Z3.z3)
(prog: prog)
name1
name2
nbwitnesses
depth
=
| let def = List.assoc name1 prog in
if None? def then failwith (Printf.sprintf "do_diff_test: parser %s not found" name1);
let args = (Some?.v def).args in
let def2 = List.assoc name2 prog in
if None? def2 then failwith (Printf.sprintf "do_diff_test: parser %s not found" name2);
if def2 <> def
then
failwith (Printf.sprintf "do_diff_test: parsers %s and %s do not have the same arg types"
name1
name2);
let nargs = count_args args in
let modul1, validator_name1 = module_and_validator_name name1 in
let modul2, validator_name2 = module_and_validator_name name2 in
with_option_out_file out_file
(fun cout ->
cout "#include <stdio.h>\n#include <stdbool.h>\n#include \"";
cout modul1;
cout ".h\"\n#include \"";
cout modul2;
cout ".h\"\n";
cout test_error_handler;
cout "\n int main(void) {\n";
let counter = alloc 0 in
do_diff_test_for out_dir counter cout z3 prog name1 name2 args nargs validator_name1
validator_name2 nbwitnesses depth;
do_diff_test_for out_dir counter cout z3 prog name2 name1 args nargs validator_name2
validator_name1 nbwitnesses depth;
cout " return 0;\n }\n") | false |
|
Z3TestGen.fst | Z3TestGen.do_test | val do_test
(out_dir: string)
(out_file: option string)
(z3: Z3.z3)
(prog: prog)
(name1: string)
(nbwitnesses: int)
(depth: nat)
(pos neg: bool)
: ML unit | val do_test
(out_dir: string)
(out_file: option string)
(z3: Z3.z3)
(prog: prog)
(name1: string)
(nbwitnesses: int)
(depth: nat)
(pos neg: bool)
: ML unit | let do_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) (name1: string) (nbwitnesses: int) (depth: nat) (pos: bool) (neg: bool) : ML unit =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = (Some?.v def).args in
let modul, validator_name = module_and_validator_name name1 in
let nargs = count_args args in with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
let tasks =
begin
if pos
then [print_witness_as_c out_dir cout true validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
mk_get_positive_test_witness name1 args
))]
else []
end `List.Tot.append`
begin
if neg
then [print_witness_as_c out_dir cout false validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
mk_get_negative_test_witness name1 args
))]
else []
end
in
witnesses_for z3 name1 args nargs tasks nbwitnesses depth;
cout " return 0;
}
"
) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1572,
"start_col": 0,
"start_line": 1532
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree
let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n"
let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= (input-size state-witness) 0)) ; validator shall consume all input
"
let mk_get_negative_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= state-witness-input-size -1)) ; validator shall genuinely fail, we are not interested in positive cases followed by garbage
"
let test_error_handler = "
static void TestErrorHandler (
const char *typename_s,
const char *fieldname,
const char *reason,
uint64_t error_code,
uint8_t *context,
EVERPARSE_INPUT_BUFFER input,
uint64_t start_pos
) {
(void) error_code;
(void) input;
if (*context) {
printf(\"Reached from position %ld: type name %s, field name %s\\n\", start_pos, typename_s, fieldname);
} else {
printf(\"Parsing failed at position %ld: type name %s, field name %s. Reason: %s\\n\", start_pos, typename_s, fieldname, reason);
*context = 1;
}
}
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out_dir: Prims.string ->
out_file: FStar.Pervasives.Native.option Prims.string ->
z3: Z3.Base.z3 ->
prog: Z3TestGen.prog ->
name1: Prims.string ->
nbwitnesses: Prims.int ->
depth: Prims.nat ->
pos: Prims.bool ->
neg: Prims.bool
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"FStar.Pervasives.Native.option",
"Z3.Base.z3",
"Z3TestGen.prog",
"Prims.int",
"Prims.nat",
"Prims.bool",
"Z3TestGen.with_option_out_file",
"Prims.unit",
"Z3TestGen.witnesses_for",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Base.seq",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"FStar.Pervasives.Native.Mktuple2",
"Z3TestGen.print_witness_as_c",
"Z3TestGen.mk_get_positive_test_witness",
"FStar.IO.print_string",
"FStar.Printf.sprintf",
"Prims.Nil",
"Z3TestGen.mk_get_negative_test_witness",
"FStar.ST.mref",
"FStar.Heap.trivial_preorder",
"FStar.ST.alloc",
"Z3TestGen.test_error_handler",
"Z3TestGen.count_args",
"Z3TestGen.module_and_validator_name",
"Z3TestGen.arg_type",
"Z3TestGen.__proj__Mkprog_def__item__args",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Z3TestGen.prog_def",
"FStar.Pervasives.Native.uu___is_None",
"FStar.All.failwith",
"FStar.List.Tot.Base.assoc"
] | [] | false | true | false | false | false | let do_test
(out_dir: string)
(out_file: option string)
(z3: Z3.z3)
(prog: prog)
(name1: string)
(nbwitnesses: int)
(depth: nat)
(pos neg: bool)
: ML unit =
| let def = List.assoc name1 prog in
if None? def then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = (Some?.v def).args in
let modul, validator_name = module_and_validator_name name1 in
let nargs = count_args args in
with_option_out_file out_file
(fun cout ->
cout "#include <stdio.h>\n#include <stdbool.h>\n#include \"";
cout modul;
cout ".h\"\n";
cout test_error_handler;
cout "\n int main(void) {\n";
let counter = alloc 0 in
let tasks =
(if pos
then
[
print_witness_as_c out_dir cout true validator_name args counter,
(fun _ ->
(FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1
);
mk_get_positive_test_witness name1 args))
]
else [])
`List.Tot.append`
(if neg
then
[
print_witness_as_c out_dir cout false validator_name args counter,
(fun _ ->
(FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1
);
mk_get_negative_test_witness name1 args))
]
else [])
in
witnesses_for z3 name1 args nargs tasks nbwitnesses depth;
cout " return 0;\n }\n") | false |
Z3TestGen.fst | Z3TestGen.produce_test_checker_exe | val produce_test_checker_exe (out_file: string) (prog: prog) (name1: string) : ML unit | val produce_test_checker_exe (out_file: string) (prog: prog) (name1: string) : ML unit | let produce_test_checker_exe (out_file: string) (prog: prog) (name1: string) : ML unit =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "produce_test_checker_exe: parser %s not found" name1);
let args = (Some?.v def).args in
let modul, validator_name = module_and_validator_name name1 in
with_out_file out_file (fun cout ->
cout (test_checker_c modul validator_name args)
) | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1737,
"start_col": 0,
"start_line": 1729
} | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int) (branch-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
; From EverParse3d.ErrorCode.is_range_okay
(define-fun is_range_okay ((size Int) (offset Int) (access_size Int)) Bool
(and
(>= size access_size)
(>= (- size access_size) offset)
)
)
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(declare-fun branch-trace (Int) Int)
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x) (branch-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)) (branch-index x))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
(branch-index x)
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state
(let ((new-size (- (input-size x) 1)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 1)
(branch-index x)
)
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state
(let ((new-size (- (input-size x) 2)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 2)
(branch-index x)
)
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 4)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 4)
(branch-index x)
)
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state
(let ((new-size (- (input-size x) 8)))
(if (< new-size 0)
-1
new-size
)
)
(+ (choice-index x) 8)
(branch-index x)
)
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
;; see EverParse3d.Actions.Base.validate_nlist_total_constant_size
(define-fun parse-nlist-total-constant-size ((size Int) (eltSize Int) (x State)) State
(if (< (input-size x) 0)
x
(if (and (= 0 (mod size eltSize)) (>= (input-size x) size))
(mk-state
(- (input-size x) size)
(+ (choice-index x) size)
(branch-index x)
)
(mk-state
-1
(choice-index x)
(branch-index x)
)
)
)
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren' id args =
mk_args_aux None id args
let mk_app_without_paren id args =
mk_app_without_paren' (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app'
(hd: string)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren' hd args })
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= parse_not_readable_app' (ident_to_string hd) args
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
let condtmp = Printf.sprintf "%s-condtmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^condtmp^" (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")))
(if (and "^condtmp^" (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 0)))
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^"
(mk-state
(input-size (after-state "^tmp^"))
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
(mk-state
(if (and (not "^condtmp^") (or (< (branch-index (after-state "^tmp^")) 0) (= (branch-trace (branch-index (after-state "^tmp^"))) 1))) -1 -2)
(choice-index (after-state "^tmp^"))
(+ (if (< (branch-index (after-state "^tmp^")) 0) 0 1) (branch-index (after-state "^tmp^")))
)
)
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let mk_parse_dep_pair
(name: string)
(binders: string)
(dfst: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
)
)
)
"
let parse_dep_pair (tag: parser reading) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let payload_binder = ident_to_string payload_binder in
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair name binders.bind body_tag.call payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse_cons
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^")))))
(if (not "^cond^")
("^f_else^" "^input^")
(mk-state -2 (choice-index "^input^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
"
let parse_ifthenelse_cons (cond: unit -> ML string) (pthen: parser not_reading) (pelse: int -> parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse (counter + 1) name_else binders false out in
out (mk_parse_ifthenelse_cons counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_ifthenelse_nil
(counter: int)
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" (if (< (branch-index "^input^") 0) "^input^" (mk-state (input-size "^input^") (choice-index "^input^") (+ 1 (branch-index "^input^"))))))
(if (and "^cond^" (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int counter^")))
("^f_then^" "^tmp^")
(if (and (not "^cond^") (or (< (branch-index "^input^") 0) (= (branch-trace (branch-index "^input^")) "^string_of_int (1 + counter)^")))
("^f_else^" "^tmp^")
(mk-state -2 (choice-index "^tmp^") (+ (if (< (branch-index "^input^") 0) 0 1) (branch-index "^input^"))) ; this is a Z3 encoding artifact, not a parsing failure
)
)
)
)
"
let parse_ifthenelse_nil (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) (counter: int) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse_nil counter name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^") (branch-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^") (branch-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
(if (> (input-size "^res^") 0)
-1
(input-size "^res^")
)
)
(choice-index "^res^")
(branch-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let itype_byte_size (i: I.itype) : Tot (option pos) = match i with
| I.UInt8 | I.UInt8BE -> Some 1
| I.UInt16 | I.UInt16BE -> Some 2
| I.UInt32 | I.UInt32BE -> Some 4
| I.UInt64 | I.UInt64BE -> Some 8
| _ -> None
let parse_nlist_total_constant_size
(i: I.itype {Some? (itype_byte_size i)}) // TODO: DT_App?
(size: I.expr)
: Tot (parser not_reading)
= parse_not_readable_app'
"parse-nlist-total-constant-size"
[
size;
T.mk_expr (T.Constant (A.Int A.UInt8 (Some?.v (itype_byte_size i))));
]
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")) (branch-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
| I.T_probe_then_validate _ _ _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec typ_depth (t: I.typ) : GTot nat
(decreases t)
= match t with
| I.T_if_else _ t1 t2 // 2 accounts for the call to parse_then_else_with_branch_trace
-> 2 + typ_depth t1 + typ_depth t2
| I.T_pair _ t1 t2
-> 1 + typ_depth t1 + typ_depth t2
| I.T_dep_pair _ _ (_, t')
| I.T_dep_pair_with_refinement _ _ _ (_, t')
| I.T_with_comment _ t' _
| I.T_at_most _ _ t'
| I.T_exact _ _ t'
| I.T_nlist _ _ t'
-> 1 + typ_depth t'
| _
-> 0
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
(decreases (typ_depth t))
=
match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse cond t1 t2 0
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body ->
if match body with
| I.T_denoted _ (I.DT_IType i) -> Some? (itype_byte_size i)
| _ -> false
then
let I.T_denoted _ (I.DT_IType i) = body in
parse_nlist_total_constant_size i size
else
parse_nlist (fun _ -> mk_expr size) (parse_typ body)
and parse_ifthenelse (cond: I.expr) (tthen: I.typ) (telse: I.typ) : Pure (int -> parser not_reading)
(requires (type_has_actions tthen == false /\ type_has_actions telse == false))
(ensures (fun _ -> True))
(decreases (1 + typ_depth tthen + typ_depth telse))
= match telse with
| I.T_if_else cond2 tthen2 telse2 ->
parse_ifthenelse_cons (fun _ -> mk_expr cond) (parse_typ tthen) (parse_ifthenelse cond2 tthen2 telse2)
| _ ->
parse_ifthenelse_nil (fun _ -> mk_expr cond) (parse_typ tthen) (parse_typ telse)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
| T.Extern_probe _
-> ()
type prog_def = {
args: list arg_type;
enum_base_type: option arg_type;
}
let prog = list (string & prog_def)
let rec arg_type_of_typ_with_prog
(accu: prog)
(t: T.typ)
: Tot (option arg_type)
(decreases t)
= match arg_type_of_typ t with
| Some ty -> Some ty
| None ->
begin match t with
| T.T_app hd _ _ ->
begin match List.Tot.assoc (ident_to_string hd) accu with
| Some def -> def.enum_base_type
| _ -> None
end
| T.T_with_action base _
| T.T_with_dep_action base _
| T.T_with_comment base _
| T.T_refine base _ ->
arg_type_of_typ_with_prog accu base
| _ -> None
end
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, {
args = List.map (fun (i, ty) -> match arg_type_of_typ_with_prog accu ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params;
enum_base_type = begin match a.enum_typ with
| Some ty -> arg_type_of_typ_with_prog accu ty
| _ -> None
end;
}) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_validator_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.validator_name modul fn
| _ -> failwith "Z3TestGen.validator_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out validator_name;
out "(";
print_witness_args_as_c out arg_types args;
out "&context, &TestErrorHandler, witness, ";
out (string_of_int witness_length);
out ", 0);"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
uint8_t context = 0;
uint64_t output = ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out validator_name arg_types witness_length args;
out " // \");
BOOLEAN result = !EverParseIsError(output);
BOOLEAN consumes_all_bytes_if_successful = true;
if (result) {
consumes_all_bytes_if_successful = (output == ";
out (string_of_int witness_length);
out "U);
result = consumes_all_bytes_if_successful;
}
if (result)
printf (\"ACCEPTED\\n\\n\");
else if (!consumes_all_bytes_if_successful)
printf (\"REJECTED (not all bytes consumed)\\n\\n\");
else
printf (\"REJECTED (failed)\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let rec mk_args_as_file_name (accu: string) (l: list string) : Tot string
(decreases l)
= match l with
| [] -> accu
| a :: q -> mk_args_as_file_name (accu ^ "." ^ a) q
let mk_output_filename
(counter: ref int)
(out_dir: string)
(validator_name: string)
(args: list string)
: ML string
= let i = !counter in
counter := i + 1;
OS.concat out_dir (mk_args_as_file_name ("witness." ^ string_of_int i ^ "." ^ validator_name) args ^ ".dat")
let print_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(positive: bool)
(validator_name: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ((if positive then "POS." else "NEG.") ^ validator_name) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive validator_name arg_types len args
)
let print_diff_witness_as_c
(out_dir: string)
(out: (string -> ML unit))
(validator_name1: string)
(validator_name2: string)
(arg_types: list arg_type)
(counter: ref int)
(witness: Seq.seq int)
(args: list string)
: ML unit
= OS.write_witness_to_file (Seq.seq_to_list witness) (mk_output_filename counter out_dir ("POS." ^ validator_name1 ^ ".NEG." ^ validator_name2) args);
print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true validator_name1 arg_types len args;
print_witness_call_as_c out false validator_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
z3.to_z3 (mk_want_another_distinct_witness witness witness_args);
if i <= 1
then ()
else
want_witnesses print_test_case z3 name l nargs (i - 1)
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
noeq
type branch_trace_node =
| Node: value: nat -> children: list branch_trace_node -> branch_trace_node
let assert_valid_state =
"(assert (or (= state-witness-input-size -1) (= state-witness-input-size 0)))\n"
let rec enumerate_branch_traces'
(z3: Z3.z3)
(max_depth cur_depth: nat)
(branch_trace: string)
: ML (list branch_trace_node)
= if max_depth = cur_depth
then []
else begin
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat"
then
let rec aux accu choice : ML (list branch_trace_node) =
let branch_trace' = branch_trace ^ " " ^ string_of_int choice in
FStar.IO.print_string (Printf.sprintf "Checking feasibility of branch trace: %s\n" branch_trace');
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "unsat"
then begin
FStar.IO.print_string "Branch condition is always false\n";
z3.to_z3 "(pop)\n";
aux accu (choice + 1)
end
else if status = "sat"
then begin
FStar.IO.print_string "Branch condition may hold. Checking validity for parser encoding\n";
z3.to_z3 "(push)\n";
z3.to_z3 assert_valid_state;
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
z3.to_z3 "(pop)\n";
if status = "sat"
then begin
FStar.IO.print_string "Branch is valid\n";
let res = enumerate_branch_traces' z3 max_depth (cur_depth + 1) branch_trace' in
z3.to_z3 "(pop)\n";
aux (Node choice res :: accu) (choice + 1)
end
else begin
FStar.IO.print_string "Branch is invalid or Z3 gave up\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
end
else begin
FStar.IO.print_string "Z3 gave up evaluating branch condition. Aborting\n";
z3.to_z3 "(pop)\n";
List.Tot.rev accu
end
in
aux [] 0
else begin
FStar.IO.print_string "Cannot take further branches under this case\n";
[]
end
end
let enumerate_branch_traces
(z3: Z3.z3)
(max_depth: nat)
: ML (list branch_trace_node)
= z3.to_z3 "(push)\n";
let res = enumerate_branch_traces' z3 max_depth 0 "" in
z3.to_z3 "(pop)\n";
res
let rec want_witnesses_with_depth
(print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) nbwitnesses
cur_depth (tree: list branch_trace_node) (branch_trace: string)
: ML unit
=
FStar.IO.print_string (Printf.sprintf "Checking witnesses for branch trace: %s\n" branch_trace);
want_witnesses print_test_case z3 name l nargs nbwitnesses;
z3.to_z3 (Printf.sprintf "(assert (> (branch-index state-witness) %d))\n" cur_depth);
let rec aux (tree: list branch_trace_node) : ML unit = match tree with
| [] -> ()
| Node choice tree' :: q ->
z3.to_z3 "(push)\n";
z3.to_z3 (Printf.sprintf "(assert (= (branch-trace %d) %d))\n" cur_depth choice);
want_witnesses_with_depth print_test_case z3 name l nargs nbwitnesses (cur_depth + 1) tree' (branch_trace ^ " " ^ string_of_int choice);
z3.to_z3 "(pop)\n";
aux q
in
aux tree
let witnesses_for (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (print_test_case_mk_get_first_witness: list ((Seq.seq int -> list string -> ML unit) & (unit -> ML string))) nbwitnesses max_depth =
z3.to_z3 "(push)\n";
z3.to_z3 (mk_get_witness name l);
let traces = enumerate_branch_traces z3 max_depth in
z3.to_z3 assert_valid_state;
List.iter
#((Seq.seq int -> list string -> ML unit) & (unit -> ML string))
(fun (ptc, f) ->
z3.to_z3 "(push)\n";
z3.to_z3 (f ());
want_witnesses_with_depth ptc z3 name l nargs nbwitnesses 0 traces "";
z3.to_z3 "(pop)\n"
)
print_test_case_mk_get_first_witness
;
z3.to_z3 "(pop)\n"
let mk_get_positive_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= (input-size state-witness) 0)) ; validator shall consume all input
"
let mk_get_negative_test_witness (name: string) (l: list arg_type) : string =
"
(assert (= state-witness-input-size -1)) ; validator shall genuinely fail, we are not interested in positive cases followed by garbage
"
let test_error_handler = "
static void TestErrorHandler (
const char *typename_s,
const char *fieldname,
const char *reason,
uint64_t error_code,
uint8_t *context,
EVERPARSE_INPUT_BUFFER input,
uint64_t start_pos
) {
(void) error_code;
(void) input;
if (*context) {
printf(\"Reached from position %ld: type name %s, field name %s\\n\", start_pos, typename_s, fieldname);
} else {
printf(\"Parsing failed at position %ld: type name %s, field name %s. Reason: %s\\n\", start_pos, typename_s, fieldname, reason);
*context = 1;
}
}
"
let do_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) (name1: string) (nbwitnesses: int) (depth: nat) (pos: bool) (neg: bool) : ML unit =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = (Some?.v def).args in
let modul, validator_name = module_and_validator_name name1 in
let nargs = count_args args in with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
let tasks =
begin
if pos
then [print_witness_as_c out_dir cout true validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
mk_get_positive_test_witness name1 args
))]
else []
end `List.Tot.append`
begin
if neg
then [print_witness_as_c out_dir cout false validator_name args counter, (fun _ -> (
FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
mk_get_negative_test_witness name1 args
))]
else []
end
in
witnesses_for z3 name1 args nargs tasks nbwitnesses depth;
cout " return 0;
}
"
)
let mk_get_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string =
let call2 = mk_call_args name2 0 l in
Printf.sprintf
"
%s
(define-fun negative-state-witness () State (%s (mk-state initial-input-size 0 -1))) ; branch trace is ignored for the second parser
(assert (not (= (input-size negative-state-witness) 0))) ; test cases that do not consume everything are considered failing
(assert (>= (input-size negative-state-witness) -1)) ; do not record tests that artificially fail due to SMT2 encoding
"
(mk_get_positive_test_witness name1 l)
call2
let do_diff_test_for (out_dir: string) (counter: ref int) (cout: string -> ML unit) (z3: Z3.z3) (prog: prog) name1 name2 args (nargs: nat { nargs == count_args args }) validator_name1 validator_name2 nbwitnesses depth =
FStar.IO.print_string (Printf.sprintf ";; Witnesses that work with %s but not with %s\n" name1 name2);
witnesses_for z3 name1 args nargs ([print_diff_witness_as_c out_dir cout validator_name1 validator_name2 args counter, (fun _ -> mk_get_diff_test_witness name1 args name2)]) nbwitnesses depth
let do_diff_test (out_dir: string) (out_file: option string) (z3: Z3.z3) (prog: prog) name1 name2 nbwitnesses depth =
let def = List.assoc name1 prog in
if None? def
then failwith (Printf.sprintf "do_diff_test: parser %s not found" name1);
let args = (Some?.v def).args in
let def2 = List.assoc name2 prog in
if None? def2
then failwith (Printf.sprintf "do_diff_test: parser %s not found" name2);
if def2 <> def
then failwith (Printf.sprintf "do_diff_test: parsers %s and %s do not have the same arg types" name1 name2);
let nargs = count_args args in
let modul1, validator_name1 = module_and_validator_name name1 in
let modul2, validator_name2 = module_and_validator_name name2 in
with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include <stdbool.h>
#include \"";
cout modul1;
cout ".h\"
#include \"";
cout modul2;
cout ".h\"
";
cout test_error_handler;
cout "
int main(void) {
";
let counter = alloc 0 in
do_diff_test_for out_dir counter cout z3 prog name1 name2 args nargs validator_name1 validator_name2 nbwitnesses depth;
do_diff_test_for out_dir counter cout z3 prog name2 name1 args nargs validator_name2 validator_name1 nbwitnesses depth;
cout " return 0;
}
"
)
let test_exe_mk_arg
(accu: (int & string & string & string))
(p: arg_type)
: Tot (int & string & string & string)
= let (cur_arg, read_args, call_args_lhs, call_args_rhs) = accu in
let cur_arg_s = string_of_int cur_arg in
let arg_var = "arg" ^ cur_arg_s in
let cur_arg' = cur_arg + 1 in
let read_args' = read_args ^
begin match p with
| ArgInt _ -> "
unsigned long long "^arg_var^" = strtoull(argv["^cur_arg_s^"], NULL, 0);
"
| ArgBool -> "
BOOLEAN "^arg_var^" = (strcmp(argv["^cur_arg_s^"], \"true\") == 0);
if (! ("^arg_var^" || strcmp(argv["^cur_arg_s^"], \"false\") == 0)) {
printf(\"Argument %d must be true or false, got %s\\n\", "^cur_arg_s^", argv["^cur_arg_s^"]);
return 1;
}
"
| _ -> "
void * "^arg_var^" = NULL;
"
end
in
let call_args_lhs' = call_args_lhs ^ arg_var ^ ", " in
let call_args_rhs' = call_args_lhs ^ ", " ^ arg_var in
(cur_arg', read_args', call_args_lhs', call_args_rhs')
let test_checker_c
(modul: string)
(validator_name: string)
(params: list arg_type)
: Tot string
=
let (nb_cmd_and_args, read_args, call_args_lhs, call_args_rhs) = List.Tot.fold_left test_exe_mk_arg (2, "", "", "") params in
let nb_cmd_and_args_s = string_of_int nb_cmd_and_args in
let nb_args_s = string_of_int (nb_cmd_and_args - 1) in
"
#include \""^modul^".h\"
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
"^test_error_handler^"
int main(int argc, char** argv) {
if (argc < "^nb_cmd_and_args_s^") {
printf(\"Wrong number of arguments, expected "^nb_args_s^", got %d\\n\", argc - 1);
return 3;
}
char * filename = argv[1];
"^read_args^"
int testfile = open(filename, O_RDONLY);
if (testfile == -1) {
printf(\"File %s does not exist\\n\", filename);
return 3;
}
struct stat statbuf;
if (fstat(testfile, &statbuf)) {
close(testfile);
printf(\"Cannot detect file size for %s\\n\", filename);
return 3;
}
off_t len = statbuf.st_size;
if (len > 4294967295) {
close(testfile);
printf(\"File is too large. EverParse/3D only supports data up to 4 GB\");
return 3;
}
uint8_t dummy = 42;
uint8_t * buf = &dummy; // for zero-sized files (mmap does not support zero-sized mappings)
void * vbuf = NULL;
if (len > 0) {
vbuf = mmap(NULL, len, PROT_READ, MAP_PRIVATE, testfile, 0);
if (vbuf == MAP_FAILED) {
close(testfile);
printf(\"Cannot read %ld bytes from %s\\n\", len, filename);
return 3;
};
buf = (uint8_t *) vbuf;
};
printf(\"Read %ld bytes from %s\\n\", len, filename);
uint8_t context = 0;
uint64_t result = "^validator_name^"("^call_args_lhs^"&context, &TestErrorHandler, buf, len, 0);
if (len > 0)
munmap(vbuf, len);
close(testfile);
if (EverParseIsError(result)) {
printf(\"Witness from %s REJECTED because validator failed\\n\", filename);
return 2;
};
if (result != (uint64_t) len) { // consistent with the postcondition of validate_with_action_t' (see also valid_length)
printf(\"Witness from %s REJECTED because validator only consumed %ld out of %ld bytes\\n\", filename, result, len);
return 1;
}
printf(\"Witness from %s ACCEPTED\\n\", filename);
return 0;
}
" | {
"checked_file": "/",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | out_file: Prims.string -> prog: Z3TestGen.prog -> name1: Prims.string -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.string",
"Z3TestGen.prog",
"Z3TestGen.with_out_file",
"Prims.unit",
"Z3TestGen.test_checker_c",
"FStar.Pervasives.Native.tuple2",
"Z3TestGen.module_and_validator_name",
"Prims.list",
"Z3TestGen.arg_type",
"Z3TestGen.__proj__Mkprog_def__item__args",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Z3TestGen.prog_def",
"FStar.Pervasives.Native.uu___is_None",
"FStar.All.failwith",
"FStar.Printf.sprintf",
"Prims.bool",
"FStar.Pervasives.Native.option",
"FStar.List.Tot.Base.assoc"
] | [] | false | true | false | false | false | let produce_test_checker_exe (out_file: string) (prog: prog) (name1: string) : ML unit =
| let def = List.assoc name1 prog in
if None? def then failwith (Printf.sprintf "produce_test_checker_exe: parser %s not found" name1);
let args = (Some?.v def).args in
let modul, validator_name = module_and_validator_name name1 in
with_out_file out_file (fun cout -> cout (test_checker_c modul validator_name args)) | false |
Steel.ST.HigherReference.fst | Steel.ST.HigherReference._free_and_pop_frame | val _free_and_pop_frame (#a: Type) (#v: erased a) (r: ref a)
: STT unit ((pts_to r full_perm v) `star` _stack_frame) (fun _ -> emp) | val _free_and_pop_frame (#a: Type) (#v: erased a) (r: ref a)
: STT unit ((pts_to r full_perm v) `star` _stack_frame) (fun _ -> emp) | let _free_and_pop_frame
(#a:Type)
(#v:erased a)
(r:ref a)
: STT unit
(pts_to r full_perm v `star` _stack_frame)
(fun _ -> emp)
= free r;
rewrite _stack_frame (pure True);
elim_pure _ | {
"file_name": "lib/steel/Steel.ST.HigherReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 13,
"end_line": 126,
"start_col": 0,
"start_line": 117
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.HigherReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
module R = Steel.HigherReference
let ref (a:Type u#1)
: Type0
= R.ref a
let null (#a:Type)
: ref a
= R.null #a
let is_null (#a:Type) (r:ref a)
: b:bool{b <==> r == null}
= R.is_null r
let pts_to (#a:Type)
(r:ref a)
([@@@smt_fallback] p:perm)
([@@@smt_fallback] v:a)
: vprop
= R.pts_to r p v
let pts_to_injective_eq
(#a: Type)
(#opened:inames)
(#p0 #p1:perm)
(#v0 #v1:a)
(r: ref a)
: STGhost unit opened
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
(requires True)
(ensures fun _ -> v0 == v1)
= coerce_ghost
(fun _ -> R.higher_ref_pts_to_injective_eq #a #opened #p0 #p1 #(hide v0) #(hide v1) r)
let pts_to_not_null #a #opened #p #v r
= extract_fact #opened (pts_to r p v) (r =!= null) (R.pts_to_not_null r p v);
()
let alloc (#a:Type) (x:a)
: ST (ref a)
emp
(fun r -> pts_to r full_perm x)
(requires True)
(ensures fun r -> not (is_null r))
= let r = coerce_steel (fun _ -> R.alloc x) in
r
let read (#a:Type)
(#p:perm)
(#v:erased a)
(r:ref a)
: ST a
(pts_to r p v)
(fun _ -> pts_to r p v)
(requires True)
(ensures fun x -> x == Ghost.reveal v)
= let u = coerce_steel (fun _ -> R.read r) in
return u
let write (#a:Type)
(#v:erased a)
(r:ref a)
(x:a)
: STT unit
(pts_to r full_perm v)
(fun _ -> pts_to r full_perm x)
= coerce_steel (fun _ -> R.write r x);
return ()
let free (#a:Type)
(#v:erased a)
(r:ref a)
: STT unit
(pts_to r full_perm v)
(fun _ -> emp)
= coerce_steel(fun _ -> R.free r);
return ()
/// Local primitive, to be extracted to Low* EPushFrame. To remember
/// that we need to call some pop_frame later, we insert some dummy
/// vprop into the context.
let _stack_frame : vprop = pure True
let _push_frame () : STT unit emp (fun _ -> _stack_frame) =
rewrite (pure True) _stack_frame
/// Local primitive, to be extracted to Low* EBufCreate
let _alloca (#a:Type) (x:a)
: ST (ref a)
emp
(fun r -> pts_to r full_perm x)
(requires True)
(ensures fun r -> not (is_null r))
= alloc x | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.HigherReference.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.HigherReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "R"
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.ST.HigherReference.ref a -> Steel.ST.Effect.STT Prims.unit | Steel.ST.Effect.STT | [] | [] | [
"FStar.Ghost.erased",
"Steel.ST.HigherReference.ref",
"Steel.ST.Util.elim_pure",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Prims.l_True",
"Prims.unit",
"Steel.ST.Util.rewrite",
"Steel.ST.HigherReference._stack_frame",
"Steel.ST.Util.pure",
"Steel.ST.HigherReference.free",
"Steel.Effect.Common.star",
"Steel.ST.HigherReference.pts_to",
"Steel.FractionalPermission.full_perm",
"FStar.Ghost.reveal",
"Steel.Effect.Common.emp",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let _free_and_pop_frame (#a: Type) (#v: erased a) (r: ref a)
: STT unit ((pts_to r full_perm v) `star` _stack_frame) (fun _ -> emp) =
| free r;
rewrite _stack_frame (pure True);
elim_pure _ | false |
LListReverse.fst | LListReverse.intro_llist_reverse_invariant | val intro_llist_reverse_invariant
(#opened: _)
(l: Ghost.erased (list U64.t))
(ppdone pptodo: ref (ref llist_cell))
(cont: bool)
(pdone: ref llist_cell)
(done: Ghost.erased (list U64.t))
(ptodo: ref llist_cell)
(todo: Ghost.erased (list U64.t))
: STGhost unit
opened
(llist_reverse_invariant_body ppdone pptodo pdone done ptodo todo)
(fun _ -> llist_reverse_invariant l ppdone pptodo cont)
(llist_reverse_invariant_prop l done todo cont)
(fun _ -> True) | val intro_llist_reverse_invariant
(#opened: _)
(l: Ghost.erased (list U64.t))
(ppdone pptodo: ref (ref llist_cell))
(cont: bool)
(pdone: ref llist_cell)
(done: Ghost.erased (list U64.t))
(ptodo: ref llist_cell)
(todo: Ghost.erased (list U64.t))
: STGhost unit
opened
(llist_reverse_invariant_body ppdone pptodo pdone done ptodo todo)
(fun _ -> llist_reverse_invariant l ppdone pptodo cont)
(llist_reverse_invariant_prop l done todo cont)
(fun _ -> True) | let intro_llist_reverse_invariant
(#opened: _)
(l: Ghost.erased (list U64.t))
(ppdone: ref (ref llist_cell))
(pptodo: ref (ref llist_cell))
(cont: bool)
(pdone: ref llist_cell)
(done: Ghost.erased (list U64.t))
(ptodo: ref llist_cell)
(todo: Ghost.erased (list U64.t))
: STGhost unit opened
(llist_reverse_invariant_body ppdone pptodo pdone done ptodo todo)
(fun _ -> llist_reverse_invariant l ppdone pptodo cont)
(llist_reverse_invariant_prop l done todo cont)
(fun _ -> True)
= let x : llist_reverse_invariant_t l cont = {
pdone = pdone;
done = done;
ptodo = ptodo;
todo = todo;
prf = ();
}
in
rewrite
(llist_reverse_invariant_body ppdone pptodo pdone done ptodo todo)
(llist_reverse_invariant_body ppdone pptodo x.pdone x.done x.ptodo x.todo);
rewrite
(llist_reverse_invariant0 l ppdone pptodo cont)
(llist_reverse_invariant l ppdone pptodo cont) | {
"file_name": "share/steel/tests/krml/LListReverse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 50,
"end_line": 171,
"start_col": 0,
"start_line": 143
} | module LListReverse
open Steel.ST.GenElim
open Steel.ST.Reference
open Steel.ST.Loops
module U64 = FStar.UInt64
let main () = C.EXIT_SUCCESS // dummy for compilation
noeq
type llist_cell = {
value: U64.t;
next: ref llist_cell;
}
[@@__reduce__]
let llist_nil
(p: ref llist_cell)
: Tot vprop
= pure (p == null)
[@@__reduce__]
let llist_cons
(a: U64.t)
(llist: (ref llist_cell -> Tot vprop))
(p: ref llist_cell)
: Tot vprop
= exists_ (fun c ->
pts_to p full_perm c `star`
pure (c.value == a) `star`
llist c.next
)
let rec llist
(l: Ghost.erased (list U64.t))
: Tot (ref llist_cell -> vprop)
(decreases Ghost.reveal l)
= match Ghost.reveal l with
| [] -> llist_nil
| a :: q -> llist_cons a (llist q)
let llist_nil_is_null
(#opened: _)
(l: Ghost.erased (list U64.t))
(p: ref llist_cell)
: STGhost unit opened
(llist l p)
(fun _ -> llist l p)
True
(fun _ -> (p == null <==> Nil? l))
= if Nil? l
then begin
rewrite (llist l p) (llist_nil p);
let _ = gen_elim () in
rewrite (llist_nil p) (llist l p)
end else begin
let a :: q = Ghost.reveal l in
rewrite (llist l p) (llist_cons a (llist q) p);
let _ = gen_elim () in
pts_to_not_null p;
rewrite (llist_cons a (llist q) p) (llist l p)
end
let pop
(#l: Ghost.erased (list U64.t))
(p: ref llist_cell { Cons? l })
: STT (ref llist_cell)
(llist l p)
(fun p' -> exists_ (fun x -> pts_to p full_perm x `star` llist (List.Tot.tl l) p' `star` pure (x.value == List.Tot.hd l)))
= rewrite (llist l p) (llist_cons (List.Tot.hd l) (llist (List.Tot.tl l)) p);
let _ = gen_elim () in
// let p' = (read p).next in // FIXME: "Effects STBase and Tot cannot be composed"
let x = read p in
let p' = x.next in
vpattern_rewrite (llist _) p';
return p'
let push
(#l': Ghost.erased (list U64.t))
(#x: Ghost.erased llist_cell)
(p: ref llist_cell)
(p': ref llist_cell)
: STT unit
(llist l' p' `star` pts_to p full_perm x)
(fun p' -> llist (x.value :: l') p)
=
// write p ({ read p with next = p' }); // weird Steel error
let x_ = read p in
write p ({ x_ with next = p' });
let x' = vpattern_replace (pts_to p full_perm) in
vpattern_rewrite (llist _) x'.next;
rewrite (llist_cons x.value (llist l') p) (llist (x.value :: l') p)
noextract
let llist_reverse_invariant_prop
(l: list U64.t)
(done todo: list U64.t)
(cont: bool)
: GTot prop
=
l == List.Tot.append (List.Tot.rev done) todo /\
cont == Cons? todo
[@@erasable]
noeq
type llist_reverse_invariant_t (l: list U64.t) (cont: bool) = {
pdone: ref llist_cell;
done: list U64.t;
ptodo: ref llist_cell;
todo: list U64.t;
prf: squash (llist_reverse_invariant_prop l done todo cont);
}
[@@__reduce__]
let llist_reverse_invariant_body
(ppdone: ref (ref llist_cell))
(pptodo: ref (ref llist_cell))
(pdone: ref llist_cell)
(done: Ghost.erased (list U64.t))
(ptodo: ref llist_cell)
(todo: Ghost.erased (list U64.t))
: Tot vprop
= pts_to ppdone full_perm pdone `star` llist done pdone `star`
pts_to pptodo full_perm ptodo `star` llist todo ptodo
[@@__reduce__]
let llist_reverse_invariant0
(l: Ghost.erased (list U64.t))
(ppdone: ref (ref llist_cell))
(pptodo: ref (ref llist_cell))
(cont: bool)
: Tot vprop
= exists_ (fun (x: llist_reverse_invariant_t l cont) -> llist_reverse_invariant_body ppdone pptodo x.pdone x.done x.ptodo x.todo)
let llist_reverse_invariant
(l: Ghost.erased (list U64.t))
(ppdone: ref (ref llist_cell))
(pptodo: ref (ref llist_cell))
(cont: bool)
: Tot vprop
= llist_reverse_invariant0 l ppdone pptodo cont | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Ghost.fsti.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "LListReverse.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "Steel.ST.Loops",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
l: FStar.Ghost.erased (Prims.list FStar.UInt64.t) ->
ppdone: Steel.ST.Reference.ref (Steel.ST.Reference.ref LListReverse.llist_cell) ->
pptodo: Steel.ST.Reference.ref (Steel.ST.Reference.ref LListReverse.llist_cell) ->
cont: Prims.bool ->
pdone: Steel.ST.Reference.ref LListReverse.llist_cell ->
done: FStar.Ghost.erased (Prims.list FStar.UInt64.t) ->
ptodo: Steel.ST.Reference.ref LListReverse.llist_cell ->
todo: FStar.Ghost.erased (Prims.list FStar.UInt64.t)
-> Steel.ST.Effect.Ghost.STGhost Prims.unit | Steel.ST.Effect.Ghost.STGhost | [] | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Prims.list",
"FStar.UInt64.t",
"Steel.ST.Reference.ref",
"LListReverse.llist_cell",
"Prims.bool",
"Steel.ST.Util.rewrite",
"LListReverse.llist_reverse_invariant0",
"LListReverse.llist_reverse_invariant",
"Prims.unit",
"LListReverse.llist_reverse_invariant_body",
"LListReverse.__proj__Mkllist_reverse_invariant_t__item__pdone",
"FStar.Ghost.reveal",
"FStar.Ghost.hide",
"LListReverse.__proj__Mkllist_reverse_invariant_t__item__done",
"LListReverse.__proj__Mkllist_reverse_invariant_t__item__ptodo",
"LListReverse.__proj__Mkllist_reverse_invariant_t__item__todo",
"LListReverse.llist_reverse_invariant_t",
"LListReverse.Mkllist_reverse_invariant_t",
"Steel.Effect.Common.vprop",
"LListReverse.llist_reverse_invariant_prop",
"Prims.l_True"
] | [] | false | true | false | false | false | let intro_llist_reverse_invariant
(#opened: _)
(l: Ghost.erased (list U64.t))
(ppdone pptodo: ref (ref llist_cell))
(cont: bool)
(pdone: ref llist_cell)
(done: Ghost.erased (list U64.t))
(ptodo: ref llist_cell)
(todo: Ghost.erased (list U64.t))
: STGhost unit
opened
(llist_reverse_invariant_body ppdone pptodo pdone done ptodo todo)
(fun _ -> llist_reverse_invariant l ppdone pptodo cont)
(llist_reverse_invariant_prop l done todo cont)
(fun _ -> True) =
| let x:llist_reverse_invariant_t l cont =
{ pdone = pdone; done = done; ptodo = ptodo; todo = todo; prf = () }
in
rewrite (llist_reverse_invariant_body ppdone pptodo pdone done ptodo todo)
(llist_reverse_invariant_body ppdone pptodo x.pdone x.done x.ptodo x.todo);
rewrite (llist_reverse_invariant0 l ppdone pptodo cont)
(llist_reverse_invariant l ppdone pptodo cont) | false |
Pulse.C.Types.Scalar.fsti | Pulse.C.Types.Scalar.read_prf | val read_prf (#t: Type) (v0: t) (p: perm)
: Lemma
(forall v0' p'.
mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p ==>
(v0' == v0 /\ p' == p)) | val read_prf (#t: Type) (v0: t) (p: perm)
: Lemma
(forall v0' p'.
mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p ==>
(v0' == v0 /\ p' == p)) | let read_prf
(#t: Type)
(v0: t)
(p: perm)
: Lemma
(forall v0' p' . (* {:pattern (mk_fraction (scalar t) (mk_scalar v0) p)} *) mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p ==> (
v0' == v0 /\
p' == p
))
=
let prf v0' p' : Lemma
(requires (mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p))
(ensures (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p))
= mk_scalar_inj (Ghost.reveal v0) v0' p p'
in
let prf' v0' p' : Lemma
((mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p) ==> (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p))
= Classical.move_requires (prf v0') p'
in
Classical.forall_intro_2 prf' | {
"file_name": "share/steel/examples/pulse/lib/c/Pulse.C.Types.Scalar.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 31,
"end_line": 129,
"start_col": 0,
"start_line": 110
} | module Pulse.C.Types.Scalar
open Pulse.Lib.Pervasives
include Pulse.C.Types.Base
// To be extracted as: t
[@@noextract_to "krml"] // primitive
val scalar_t ( [@@@strictly_positive] t: Type0) : Type0
[@@noextract_to "krml"] // proof-only
val scalar (t: Type) : typedef (scalar_t t)
val mk_scalar (#t: Type) (v: t) : Ghost (scalar_t t)
(requires True)
(ensures (fun y ->
fractionable (scalar t) y /\
full (scalar t) y
))
val mk_scalar_fractionable
(#t: Type)
(v: t)
(p: perm)
: Lemma
(requires (fractionable (scalar t) (mk_fraction (scalar t) (mk_scalar v) p)))
(ensures (p `lesser_equal_perm` full_perm))
val mk_scalar_inj
(#t: Type)
(v1 v2: t)
(p1 p2: perm)
: Lemma
(requires (mk_fraction (scalar t) (mk_scalar v1) p1 == mk_fraction (scalar t) (mk_scalar v2) p2))
(ensures (v1 == v2 /\ p1 == p2))
[SMTPat [mk_fraction (scalar t) (mk_scalar v1) p1; mk_fraction (scalar t) (mk_scalar v2) p2]]
```pulse
ghost
fn scalar_unique
(#t: Type)
(v1 v2: t)
(p1 p2: perm)
(r: ref (scalar t))
requires
(pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) ** pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
ensures
(pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) ** pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2) ** pure (
v1 == v2 /\ (p1 `sum_perm` p2) `lesser_equal_perm` full_perm
))
{
fractional_permissions_theorem (mk_scalar v1) (mk_scalar v2) p1 p2 r;
let _ = mk_scalar_inj v1 v2 full_perm full_perm;
()
}
```
[@@noextract_to "krml"] // primitive
val read0 (#t: Type) (#v: Ghost.erased t) (#p: perm) (r: ref (scalar t))
: stt t
(pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
(fun v' -> pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p) ** pure (
v' == Ghost.reveal v
))
let mk_fraction_full_scalar (#t: Type) (v: t) : Lemma
(mk_scalar v == mk_fraction (scalar t) (mk_scalar v) full_perm)
[SMTPat (mk_scalar v)]
= ()
val get_scalar_value
(#t: Type)
(c: scalar_t t)
: GTot (option t)
val get_scalar_value_mk_fraction
(#t: Type)
(c: scalar_t t)
(p: perm)
: Lemma
(requires (fractionable (scalar t) c))
(ensures (get_scalar_value (mk_fraction (scalar t) c p) == get_scalar_value c))
[SMTPat (get_scalar_value (mk_fraction (scalar t) c p))]
val get_scalar_value_mk_scalar
(#t: Type)
(c: t)
: Lemma
(get_scalar_value (mk_scalar c) == Some c)
[SMTPat (get_scalar_value (mk_scalar c))]
val get_scalar_value_uninitialized
(t: Type)
: Lemma
(get_scalar_value (uninitialized (scalar t)) == None)
[SMTPat (get_scalar_value (uninitialized (scalar t)))]
val get_scalar_value_unknown
(t: Type)
: Lemma
(get_scalar_value (unknown (scalar t)) == None)
[SMTPat (get_scalar_value (unknown (scalar t)))]
val get_scalar_value_some
(#t: Type)
(c: scalar_t t)
: Lemma
(requires (Some? (get_scalar_value c)))
(ensures (
exists v0 p . Ghost.reveal c == mk_fraction (scalar t) (mk_scalar v0) p
))
[SMTPat (get_scalar_value c)] | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.C.Types.Base.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.C.Types.Scalar.fsti"
} | [
{
"abbrev": false,
"full_module": "Pulse.C.Types.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.C.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.C.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v0: t -> p: PulseCore.FractionalPermission.perm
-> FStar.Pervasives.Lemma
(ensures
forall (v0': t) (p': PulseCore.FractionalPermission.perm).
Pulse.C.Types.Base.mk_fraction (Pulse.C.Types.Scalar.scalar t)
(Pulse.C.Types.Scalar.mk_scalar v0')
p' ==
Pulse.C.Types.Base.mk_fraction (Pulse.C.Types.Scalar.scalar t)
(Pulse.C.Types.Scalar.mk_scalar v0)
p ==>
v0' == v0 /\ p' == p) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"PulseCore.FractionalPermission.perm",
"FStar.Classical.forall_intro_2",
"Prims.l_imp",
"Prims.eq2",
"Pulse.C.Types.Scalar.scalar_t",
"Pulse.C.Types.Base.mk_fraction",
"Pulse.C.Types.Scalar.scalar",
"Pulse.C.Types.Scalar.mk_scalar",
"Prims.l_and",
"FStar.Ghost.reveal",
"FStar.Ghost.hide",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Classical.move_requires",
"Pulse.C.Types.Scalar.mk_scalar_inj",
"Prims.l_Forall"
] | [] | false | false | true | false | false | let read_prf (#t: Type) (v0: t) (p: perm)
: Lemma
(forall v0' p'.
mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p ==>
(v0' == v0 /\ p' == p)) =
| let prf v0' p'
: Lemma
(requires
(mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p))
(ensures (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p)) =
mk_scalar_inj (Ghost.reveal v0) v0' p p'
in
let prf' v0' p'
: Lemma
((mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p) ==>
(v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p)) =
Classical.move_requires (prf v0') p'
in
Classical.forall_intro_2 prf' | false |
Pulse.C.Types.Scalar.fsti | Pulse.C.Types.Scalar.indefinite_description_tot0 | val indefinite_description_tot0 (a: Type) (p: (a -> prop)) (q: squash (exists x. p x))
: Tot (w: Ghost.erased a {p w}) | val indefinite_description_tot0 (a: Type) (p: (a -> prop)) (q: squash (exists x. p x))
: Tot (w: Ghost.erased a {p w}) | let indefinite_description_tot0 (a:Type) (p:(a -> prop)) (q: squash (exists x. p x))
: Tot (w:Ghost.erased a{ p w })
= FStar.IndefiniteDescription.indefinite_description_tot a p | {
"file_name": "share/steel/examples/pulse/lib/c/Pulse.C.Types.Scalar.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 60,
"end_line": 134,
"start_col": 0,
"start_line": 132
} | module Pulse.C.Types.Scalar
open Pulse.Lib.Pervasives
include Pulse.C.Types.Base
// To be extracted as: t
[@@noextract_to "krml"] // primitive
val scalar_t ( [@@@strictly_positive] t: Type0) : Type0
[@@noextract_to "krml"] // proof-only
val scalar (t: Type) : typedef (scalar_t t)
val mk_scalar (#t: Type) (v: t) : Ghost (scalar_t t)
(requires True)
(ensures (fun y ->
fractionable (scalar t) y /\
full (scalar t) y
))
val mk_scalar_fractionable
(#t: Type)
(v: t)
(p: perm)
: Lemma
(requires (fractionable (scalar t) (mk_fraction (scalar t) (mk_scalar v) p)))
(ensures (p `lesser_equal_perm` full_perm))
val mk_scalar_inj
(#t: Type)
(v1 v2: t)
(p1 p2: perm)
: Lemma
(requires (mk_fraction (scalar t) (mk_scalar v1) p1 == mk_fraction (scalar t) (mk_scalar v2) p2))
(ensures (v1 == v2 /\ p1 == p2))
[SMTPat [mk_fraction (scalar t) (mk_scalar v1) p1; mk_fraction (scalar t) (mk_scalar v2) p2]]
```pulse
ghost
fn scalar_unique
(#t: Type)
(v1 v2: t)
(p1 p2: perm)
(r: ref (scalar t))
requires
(pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) ** pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
ensures
(pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) ** pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2) ** pure (
v1 == v2 /\ (p1 `sum_perm` p2) `lesser_equal_perm` full_perm
))
{
fractional_permissions_theorem (mk_scalar v1) (mk_scalar v2) p1 p2 r;
let _ = mk_scalar_inj v1 v2 full_perm full_perm;
()
}
```
[@@noextract_to "krml"] // primitive
val read0 (#t: Type) (#v: Ghost.erased t) (#p: perm) (r: ref (scalar t))
: stt t
(pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
(fun v' -> pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p) ** pure (
v' == Ghost.reveal v
))
let mk_fraction_full_scalar (#t: Type) (v: t) : Lemma
(mk_scalar v == mk_fraction (scalar t) (mk_scalar v) full_perm)
[SMTPat (mk_scalar v)]
= ()
val get_scalar_value
(#t: Type)
(c: scalar_t t)
: GTot (option t)
val get_scalar_value_mk_fraction
(#t: Type)
(c: scalar_t t)
(p: perm)
: Lemma
(requires (fractionable (scalar t) c))
(ensures (get_scalar_value (mk_fraction (scalar t) c p) == get_scalar_value c))
[SMTPat (get_scalar_value (mk_fraction (scalar t) c p))]
val get_scalar_value_mk_scalar
(#t: Type)
(c: t)
: Lemma
(get_scalar_value (mk_scalar c) == Some c)
[SMTPat (get_scalar_value (mk_scalar c))]
val get_scalar_value_uninitialized
(t: Type)
: Lemma
(get_scalar_value (uninitialized (scalar t)) == None)
[SMTPat (get_scalar_value (uninitialized (scalar t)))]
val get_scalar_value_unknown
(t: Type)
: Lemma
(get_scalar_value (unknown (scalar t)) == None)
[SMTPat (get_scalar_value (unknown (scalar t)))]
val get_scalar_value_some
(#t: Type)
(c: scalar_t t)
: Lemma
(requires (Some? (get_scalar_value c)))
(ensures (
exists v0 p . Ghost.reveal c == mk_fraction (scalar t) (mk_scalar v0) p
))
[SMTPat (get_scalar_value c)]
let read_prf
(#t: Type)
(v0: t)
(p: perm)
: Lemma
(forall v0' p' . (* {:pattern (mk_fraction (scalar t) (mk_scalar v0) p)} *) mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p ==> (
v0' == v0 /\
p' == p
))
=
let prf v0' p' : Lemma
(requires (mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p))
(ensures (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p))
= mk_scalar_inj (Ghost.reveal v0) v0' p p'
in
let prf' v0' p' : Lemma
((mk_fraction (scalar t) (mk_scalar v0') p' == mk_fraction (scalar t) (mk_scalar v0) p) ==> (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p))
= Classical.move_requires (prf v0') p'
in
Classical.forall_intro_2 prf' | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.C.Types.Base.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.C.Types.Scalar.fsti"
} | [
{
"abbrev": false,
"full_module": "Pulse.C.Types.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.C.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.C.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type -> p: (_: a -> Prims.prop) -> q: Prims.squash (exists (x: a). p x)
-> w: FStar.Ghost.erased a {p (FStar.Ghost.reveal w)} | Prims.Tot | [
"total"
] | [] | [
"Prims.prop",
"Prims.squash",
"Prims.l_Exists",
"FStar.IndefiniteDescription.indefinite_description_tot",
"FStar.Ghost.erased",
"FStar.Ghost.reveal"
] | [] | false | false | false | false | false | let indefinite_description_tot0 (a: Type) (p: (a -> prop)) (q: squash (exists x. p x))
: Tot (w: Ghost.erased a {p w}) =
| FStar.IndefiniteDescription.indefinite_description_tot a p | false |
LListReverse.fst | LListReverse.elim_llist_reverse_invariant | val elim_llist_reverse_invariant
(#opened: _)
(l: Ghost.erased (list U64.t))
(ppdone pptodo: ref (ref llist_cell))
(cont: bool)
: STGhostT (llist_reverse_invariant_t l cont)
opened
(llist_reverse_invariant l ppdone pptodo cont)
(fun x -> llist_reverse_invariant_body ppdone pptodo x.pdone x.done x.ptodo x.todo) | val elim_llist_reverse_invariant
(#opened: _)
(l: Ghost.erased (list U64.t))
(ppdone pptodo: ref (ref llist_cell))
(cont: bool)
: STGhostT (llist_reverse_invariant_t l cont)
opened
(llist_reverse_invariant l ppdone pptodo cont)
(fun x -> llist_reverse_invariant_body ppdone pptodo x.pdone x.done x.ptodo x.todo) | let elim_llist_reverse_invariant
(#opened: _)
(l: Ghost.erased (list U64.t))
(ppdone: ref (ref llist_cell))
(pptodo: ref (ref llist_cell))
(cont: bool)
: STGhostT (llist_reverse_invariant_t l cont) opened
(llist_reverse_invariant l ppdone pptodo cont)
(fun x -> llist_reverse_invariant_body ppdone pptodo x.pdone x.done x.ptodo x.todo)
= let x = elim_exists () in
x | {
"file_name": "share/steel/tests/krml/LListReverse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 3,
"end_line": 183,
"start_col": 0,
"start_line": 173
} | module LListReverse
open Steel.ST.GenElim
open Steel.ST.Reference
open Steel.ST.Loops
module U64 = FStar.UInt64
let main () = C.EXIT_SUCCESS // dummy for compilation
noeq
type llist_cell = {
value: U64.t;
next: ref llist_cell;
}
[@@__reduce__]
let llist_nil
(p: ref llist_cell)
: Tot vprop
= pure (p == null)
[@@__reduce__]
let llist_cons
(a: U64.t)
(llist: (ref llist_cell -> Tot vprop))
(p: ref llist_cell)
: Tot vprop
= exists_ (fun c ->
pts_to p full_perm c `star`
pure (c.value == a) `star`
llist c.next
)
let rec llist
(l: Ghost.erased (list U64.t))
: Tot (ref llist_cell -> vprop)
(decreases Ghost.reveal l)
= match Ghost.reveal l with
| [] -> llist_nil
| a :: q -> llist_cons a (llist q)
let llist_nil_is_null
(#opened: _)
(l: Ghost.erased (list U64.t))
(p: ref llist_cell)
: STGhost unit opened
(llist l p)
(fun _ -> llist l p)
True
(fun _ -> (p == null <==> Nil? l))
= if Nil? l
then begin
rewrite (llist l p) (llist_nil p);
let _ = gen_elim () in
rewrite (llist_nil p) (llist l p)
end else begin
let a :: q = Ghost.reveal l in
rewrite (llist l p) (llist_cons a (llist q) p);
let _ = gen_elim () in
pts_to_not_null p;
rewrite (llist_cons a (llist q) p) (llist l p)
end
let pop
(#l: Ghost.erased (list U64.t))
(p: ref llist_cell { Cons? l })
: STT (ref llist_cell)
(llist l p)
(fun p' -> exists_ (fun x -> pts_to p full_perm x `star` llist (List.Tot.tl l) p' `star` pure (x.value == List.Tot.hd l)))
= rewrite (llist l p) (llist_cons (List.Tot.hd l) (llist (List.Tot.tl l)) p);
let _ = gen_elim () in
// let p' = (read p).next in // FIXME: "Effects STBase and Tot cannot be composed"
let x = read p in
let p' = x.next in
vpattern_rewrite (llist _) p';
return p'
let push
(#l': Ghost.erased (list U64.t))
(#x: Ghost.erased llist_cell)
(p: ref llist_cell)
(p': ref llist_cell)
: STT unit
(llist l' p' `star` pts_to p full_perm x)
(fun p' -> llist (x.value :: l') p)
=
// write p ({ read p with next = p' }); // weird Steel error
let x_ = read p in
write p ({ x_ with next = p' });
let x' = vpattern_replace (pts_to p full_perm) in
vpattern_rewrite (llist _) x'.next;
rewrite (llist_cons x.value (llist l') p) (llist (x.value :: l') p)
noextract
let llist_reverse_invariant_prop
(l: list U64.t)
(done todo: list U64.t)
(cont: bool)
: GTot prop
=
l == List.Tot.append (List.Tot.rev done) todo /\
cont == Cons? todo
[@@erasable]
noeq
type llist_reverse_invariant_t (l: list U64.t) (cont: bool) = {
pdone: ref llist_cell;
done: list U64.t;
ptodo: ref llist_cell;
todo: list U64.t;
prf: squash (llist_reverse_invariant_prop l done todo cont);
}
[@@__reduce__]
let llist_reverse_invariant_body
(ppdone: ref (ref llist_cell))
(pptodo: ref (ref llist_cell))
(pdone: ref llist_cell)
(done: Ghost.erased (list U64.t))
(ptodo: ref llist_cell)
(todo: Ghost.erased (list U64.t))
: Tot vprop
= pts_to ppdone full_perm pdone `star` llist done pdone `star`
pts_to pptodo full_perm ptodo `star` llist todo ptodo
[@@__reduce__]
let llist_reverse_invariant0
(l: Ghost.erased (list U64.t))
(ppdone: ref (ref llist_cell))
(pptodo: ref (ref llist_cell))
(cont: bool)
: Tot vprop
= exists_ (fun (x: llist_reverse_invariant_t l cont) -> llist_reverse_invariant_body ppdone pptodo x.pdone x.done x.ptodo x.todo)
let llist_reverse_invariant
(l: Ghost.erased (list U64.t))
(ppdone: ref (ref llist_cell))
(pptodo: ref (ref llist_cell))
(cont: bool)
: Tot vprop
= llist_reverse_invariant0 l ppdone pptodo cont
let intro_llist_reverse_invariant
(#opened: _)
(l: Ghost.erased (list U64.t))
(ppdone: ref (ref llist_cell))
(pptodo: ref (ref llist_cell))
(cont: bool)
(pdone: ref llist_cell)
(done: Ghost.erased (list U64.t))
(ptodo: ref llist_cell)
(todo: Ghost.erased (list U64.t))
: STGhost unit opened
(llist_reverse_invariant_body ppdone pptodo pdone done ptodo todo)
(fun _ -> llist_reverse_invariant l ppdone pptodo cont)
(llist_reverse_invariant_prop l done todo cont)
(fun _ -> True)
= let x : llist_reverse_invariant_t l cont = {
pdone = pdone;
done = done;
ptodo = ptodo;
todo = todo;
prf = ();
}
in
rewrite
(llist_reverse_invariant_body ppdone pptodo pdone done ptodo todo)
(llist_reverse_invariant_body ppdone pptodo x.pdone x.done x.ptodo x.todo);
rewrite
(llist_reverse_invariant0 l ppdone pptodo cont)
(llist_reverse_invariant l ppdone pptodo cont) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Ghost.fsti.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "LListReverse.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "Steel.ST.Loops",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
l: FStar.Ghost.erased (Prims.list FStar.UInt64.t) ->
ppdone: Steel.ST.Reference.ref (Steel.ST.Reference.ref LListReverse.llist_cell) ->
pptodo: Steel.ST.Reference.ref (Steel.ST.Reference.ref LListReverse.llist_cell) ->
cont: Prims.bool
-> Steel.ST.Effect.Ghost.STGhostT
(LListReverse.llist_reverse_invariant_t (FStar.Ghost.reveal l) cont) | Steel.ST.Effect.Ghost.STGhostT | [] | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Prims.list",
"FStar.UInt64.t",
"Steel.ST.Reference.ref",
"LListReverse.llist_cell",
"Prims.bool",
"FStar.Ghost.reveal",
"LListReverse.llist_reverse_invariant_t",
"Steel.ST.Util.elim_exists",
"LListReverse.llist_reverse_invariant_body",
"LListReverse.__proj__Mkllist_reverse_invariant_t__item__pdone",
"FStar.Ghost.hide",
"LListReverse.__proj__Mkllist_reverse_invariant_t__item__done",
"LListReverse.__proj__Mkllist_reverse_invariant_t__item__ptodo",
"LListReverse.__proj__Mkllist_reverse_invariant_t__item__todo",
"Steel.Effect.Common.vprop",
"LListReverse.llist_reverse_invariant"
] | [] | false | true | false | false | false | let elim_llist_reverse_invariant
(#opened: _)
(l: Ghost.erased (list U64.t))
(ppdone pptodo: ref (ref llist_cell))
(cont: bool)
: STGhostT (llist_reverse_invariant_t l cont)
opened
(llist_reverse_invariant l ppdone pptodo cont)
(fun x -> llist_reverse_invariant_body ppdone pptodo x.pdone x.done x.ptodo x.todo) =
| let x = elim_exists () in
x | false |
Hacl.Impl.Blake2.Generic.fst | Hacl.Impl.Blake2.Generic.blake2 | val blake2:
#al:Spec.alg
-> #ms:m_spec
-> blake2_init_st al ms
-> blake2_update_st al ms
-> blake2_finish_st al ms
-> blake2_st al ms | val blake2:
#al:Spec.alg
-> #ms:m_spec
-> blake2_init_st al ms
-> blake2_update_st al ms
-> blake2_finish_st al ms
-> blake2_st al ms | let blake2 #al #ms blake2_init blake2_update blake2_finish output output_len input input_len key key_len =
[@inline_let]
let stlen = le_sigh al ms in
[@inline_let]
let stzero = zero_element al ms in
let h0 = ST.get() in
[@inline_let]
let spec _ h1 = h1.[|output|] == Spec.blake2 al h0.[|(input <: lbuffer uint8 input_len)|] (Spec.blake2_default_params al) (v key_len) h0.[|key|] (v output_len) in
salloc1 h0 stlen stzero (Ghost.hide (loc output)) spec
(fun h ->
assert (max_size_t <= Spec.max_limb al);
let h1 = ST.get() in
salloc1 h1 stlen stzero (Ghost.hide (loc output |+| loc h)) spec
(fun wv ->
blake2_init h key_len output_len;
blake2_update wv h key_len key input_len input;
blake2_finish output_len output h)) | {
"file_name": "code/blake2/Hacl.Impl.Blake2.Generic.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 1041,
"start_col": 0,
"start_line": 1025
} | module Hacl.Impl.Blake2.Generic
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Lib.LoopCombinators
module ST = FStar.HyperStack.ST
module Seq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Spec = Spec.Blake2
open Hacl.Impl.Blake2.Constants
open Hacl.Impl.Blake2.Core
#set-options "--z3rlimit 50 --max_ifuel 0 --max_fuel 0"
noextract
let is_valid_blake2_config (a : Spec.alg) (m : m_spec) =
match a, m with
| Spec.Blake2S, M32 | Spec.Blake2S, M128
| Spec.Blake2B, M32 | Spec.Blake2B, M256 -> true
| _ -> false
inline_for_extraction noextract
let valid_m_spec (a : Spec.alg) = m:m_spec{is_valid_blake2_config a m}
/// Accessors for constants
inline_for_extraction noextract
val get_iv:
a:Spec.alg
-> s: size_t{size_v s < 8} ->
Stack (word_t a)
(requires (fun h -> True))
(ensures (fun h0 z h1 -> h0 == h1 /\
v z == v (Seq.index (Spec.ivTable a) (v s))))
let get_iv a s =
recall_contents #(Spec.pub_word_t Spec.Blake2S) #8ul ivTable_S (Spec.ivTable Spec.Blake2S);
recall_contents #(Spec.pub_word_t Spec.Blake2B) #8ul ivTable_B (Spec.ivTable Spec.Blake2B);
[@inline_let]
let ivTable: (x:glbuffer (Spec.pub_word_t a) 8ul{witnessed x (Spec.ivTable a) /\ recallable x}) =
match a with
| Spec.Blake2S -> ivTable_S
| Spec.Blake2B -> ivTable_B
in
let r = index ivTable s in
secret #(Spec.wt a) r
inline_for_extraction noextract
val get_sigma:
s: size_t{v s < 160} ->
Stack Spec.sigma_elt_t
(requires (fun h -> True))
(ensures (fun h0 z h1 -> h0 == h1 /\ z == Lib.Sequence.(Spec.sigmaTable.[v s])))
let get_sigma s =
recall_contents sigmaTable Spec.sigmaTable;
index sigmaTable s
inline_for_extraction noextract
val get_sigma_sub:
start: size_t ->
i: size_t{v i < 16 /\ v start + v i < 160} ->
Stack Spec.sigma_elt_t
(requires (fun h -> True))
(ensures (fun h0 z h1 -> h0 == h1 /\ v z == v (Seq.index Spec.sigmaTable (v start + v i))))
let get_sigma_sub start i = get_sigma (start +. i)
inline_for_extraction noextract
let rounds_t (a:Spec.alg): size_t = size (Spec.rounds a)
inline_for_extraction noextract
val size_to_word: al:Spec.alg -> s:size_t -> u:word_t al{u == Spec.nat_to_word al (v s)}
let size_to_word al s = match al with
| Spec.Blake2S -> size_to_uint32 s
| Spec.Blake2B -> size_to_uint64 s
inline_for_extraction noextract
val size_to_limb: al:Spec.alg -> s:size_t -> u:Spec.limb_t al{u == Spec.nat_to_limb al (v s)}
let size_to_limb al s = match al with
| Spec.Blake2S -> size_to_uint64 s
| Spec.Blake2B -> to_u128 (size_to_uint64 s)
/// Constants
/// Define algorithm functions
inline_for_extraction noextract
val g1: #al:Spec.alg -> #m:m_spec -> wv:state_p al m -> a:index_t -> b:index_t -> r:rotval (Spec.wt al) ->
Stack unit
(requires (fun h -> live h wv /\ a <> b))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ (state_v h1 wv) == Spec.g1 al (state_v h0 wv) (v a) (v b) r))
let g1 #al #m wv a b r =
let h0 = ST.get() in
let wv_a = rowi wv a in
let wv_b = rowi wv b in
xor_row wv_a wv_b;
ror_row wv_a r;
let h2 = ST.get() in
Lib.Sequence.eq_intro (state_v h2 wv) (Spec.g1 al (state_v h0 wv) (v a) (v b) r)
#push-options "--z3rlimit 100 --max_fuel 1 --max_ifuel 1"
inline_for_extraction noextract
val g2: #al:Spec.alg -> #m:m_spec -> wv:state_p al m -> a:index_t -> b:index_t -> x:row_p al m ->
Stack unit
(requires (fun h -> live h wv /\ live h x /\ disjoint wv x /\ a <> b))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ state_v h1 wv == Spec.g2 al (state_v h0 wv) (v a) (v b) (row_v h0 x)))
let g2 #al #m wv a b x =
let h0 = ST.get() in
let wv_a = rowi wv a in
let wv_b = rowi wv b in
add_row wv_a wv_b;
add_row wv_a x;
let h1 = ST.get() in
Lib.Sequence.eq_intro (state_v h1 wv) (Spec.g2 al (state_v h0 wv) (v a) (v b) (row_v h0 x))
#push-options "--z3rlimit 100 --max_fuel 1 --max_ifuel 1"
inline_for_extraction noextract
val g2z: #al:Spec.alg -> #m:m_spec -> wv:state_p al m -> a:index_t -> b:index_t ->
Stack unit
(requires (fun h -> live h wv /\ a <> b))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ state_v h1 wv == Spec.g2z al (state_v h0 wv) (v a) (v b)))
let g2z #al #m wv a b =
let h0 = ST.get() in
let wv_a = rowi wv a in
let wv_b = rowi wv b in
add_row wv_a wv_b;
let h1 = ST.get() in
Lib.Sequence.eq_intro (state_v h1 wv) (Spec.g2z al (state_v h0 wv) (v a) (v b))
inline_for_extraction noextract
val blake2_mixing : #al:Spec.alg -> #m:m_spec -> wv:state_p al m -> x:row_p al m -> y:row_p al m ->
Stack unit
(requires (fun h -> live h wv /\ live h x /\ live h y /\ disjoint wv x /\ disjoint wv y))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ state_v h1 wv == Spec.blake2_mixing al (state_v h0 wv) (row_v h0 x) (row_v h0 y)))
let blake2_mixing #al #m wv x y =
let h0 = ST.get() in
push_frame ();
let a = 0ul in
let b = 1ul in
let c = 2ul in
let d = 3ul in
[@inline_let]
let r0 = normalize_term (Lib.Sequence.index (Spec.rTable al) 0) in
normalize_term_spec (Lib.Sequence.index (Spec.rTable al) 0);
[@inline_let]
let r1 = normalize_term (Lib.Sequence.index (Spec.rTable al) 1) in
normalize_term_spec (Lib.Sequence.index (Spec.rTable al) 1);
[@inline_let]
let r2 = normalize_term (Lib.Sequence.index (Spec.rTable al) 2) in
normalize_term_spec (Lib.Sequence.index (Spec.rTable al) 2);
[@inline_let]
let r3 = normalize_term (Lib.Sequence.index (Spec.rTable al) 3) in
normalize_term_spec (Lib.Sequence.index (Spec.rTable al) 3);
let h1 = ST.get() in
g2 wv a b x;
g1 wv d a r0;
g2z wv c d;
g1 wv b c r1;
g2 wv a b y;
g1 wv d a r2;
g2z wv c d;
g1 wv b c r3;
let h2 = ST.get() in
pop_frame ();
let h3 = ST.get() in
assert(modifies (loc wv) h0 h3);
Lib.Sequence.eq_intro (state_v h2 wv) (Spec.blake2_mixing al (state_v h1 wv) (row_v h1 x) (row_v h1 y))
#pop-options
inline_for_extraction noextract
val diag: #a:Spec.alg -> #m:m_spec -> wv:state_p a m
-> Stack unit
(requires (fun h -> live h wv))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1 /\
state_v h1 wv == Spec.diag (state_v h0 wv)))
let diag #a #m wv =
let r1 = rowi wv 1ul in
let r2 = rowi wv 2ul in
let r3 = rowi wv 3ul in
let h0 = ST.get() in
permr_row r1 1ul;
permr_row r2 2ul;
permr_row r3 3ul
inline_for_extraction noextract
val undiag: #a:Spec.alg -> #m:m_spec -> wv:state_p a m
-> Stack unit
(requires (fun h -> live h wv))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1 /\
state_v h1 wv == Spec.undiag (state_v h0 wv)))
let undiag #a #m wv =
let r1 = rowi wv 1ul in
let r2 = rowi wv 2ul in
let r3 = rowi wv 3ul in
let h0 = ST.get() in
permr_row r1 3ul;
permr_row r2 2ul;
permr_row r3 1ul
inline_for_extraction noextract
val gather_state: #a:Spec.alg -> #ms:m_spec -> st:state_p a ms -> m:block_w a -> start:size_t{v start <= 144} -> Stack unit
(requires (fun h -> live h st /\ live h m /\ disjoint st m))
(ensures (fun h0 _ h1 -> modifies (loc st) h0 h1 /\
state_v h1 st == Spec.gather_state a (as_seq h0 m) (v start)))
inline_for_extraction noextract
let get_sigma' (start: size_t { v start <= 144 }) (i: size_t { normalize (i <=. 15ul) }):
Stack Spec.sigma_elt_t
(requires (fun h -> True))
(ensures (fun h0 z h1 ->
h0 == h1 /\ z == Lib.Sequence.(Spec.sigmaTable.[v start + v i])))
=
get_sigma (start +! i)
#push-options "--z3rlimit 500"
let gather_state #a #ms st m start =
let h0 = ST.get() in
let r0 = rowi st 0ul in
let r1 = rowi st 1ul in
let r2 = rowi st 2ul in
let r3 = rowi st 3ul in
let s0 = get_sigma' start 0ul in
let s1 = get_sigma' start 1ul in
let s2 = get_sigma' start 2ul in
let s3 = get_sigma' start 3ul in
let s4 = get_sigma' start 4ul in
let s5 = get_sigma' start 5ul in
let s6 = get_sigma' start 6ul in
let s7 = get_sigma' start 7ul in
let s8 = get_sigma' start 8ul in
let s9 = get_sigma' start 9ul in
let s10 = get_sigma' start 10ul in
let s11 = get_sigma' start 11ul in
let s12 = get_sigma' start 12ul in
let s13 = get_sigma' start 13ul in
let s14 = get_sigma' start 14ul in
let s15 = get_sigma' start 15ul in
let h1 = ST.get() in
gather_row r0 m s0 s2 s4 s6;
let h2 = ST.get() in
gather_row r1 m s1 s3 s5 s7;
let h3 = ST.get() in
gather_row r2 m s8 s10 s12 s14;
let h4 = ST.get() in
gather_row r3 m s9 s11 s13 s15;
let h5 = ST.get() in
assert(modifies (loc st) h0 h5);
Lib.Sequence.eq_intro (state_v h5 st) (Spec.gather_state a (as_seq h0 m) (v start))
inline_for_extraction noextract
val blake2_round : #al:Spec.alg -> #ms:m_spec -> wv:state_p al ms -> m:block_w al -> i:size_t ->
Stack unit
(requires (fun h -> live h wv /\ live h m /\ disjoint wv m))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ state_v h1 wv == Spec.blake2_round al (as_seq h0 m) (v i) (state_v h0 wv)))
let blake2_round #al #ms wv m i =
push_frame();
let start_idx = (i %. size 10) *. size 16 in
assert (v start_idx == (v i % 10) * 16);
assert (v start_idx <= 144);
let m_st = alloc_state al ms in
gather_state m_st m start_idx;
let x = rowi m_st 0ul in
let y = rowi m_st 1ul in
let z = rowi m_st 2ul in
let w = rowi m_st 3ul in
let h1 = ST.get() in
assert (disjoint wv m_st);
assert (disjoint m_st wv);
assert (disjoint x wv);
assert (disjoint wv x);
assert (disjoint y wv);
assert (disjoint wv y);
assert (disjoint z wv);
assert (disjoint wv z);
assert (disjoint w wv);
assert (disjoint wv w);
blake2_mixing wv x y;
diag wv;
blake2_mixing wv z w;
undiag wv;
pop_frame ()
inline_for_extraction noextract
val blake2_compress0:
#al:Spec.alg
-> m_s: block_p al
-> m_w: block_w al
-> Stack unit
(requires (fun h -> live h m_s /\ live h m_w /\ disjoint m_s m_w))
(ensures (fun h0 _ h1 -> modifies (loc m_w) h0 h1
/\ as_seq h1 m_w == Spec.blake2_compress0 al (as_seq h0 m_s)))
let blake2_compress0 #al m_s m_w =
uints_from_bytes_le m_w m_s
inline_for_extraction noextract
val blake2_compress1:
#al:Spec.alg
-> #m:m_spec
-> wv: state_p al m
-> s_iv: state_p al m
-> offset: Spec.limb_t al
-> flag: bool ->
Stack unit
(requires (fun h -> live h wv /\ live h s_iv /\ disjoint wv s_iv))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ state_v h1 wv == Spec.blake2_compress1 al (state_v h0 s_iv) offset flag))
let blake2_compress1 #al #m wv s_iv offset flag =
let h0 = ST.get() in
push_frame();
let mask = alloc_row al m in
[@inline_let]
let wv_12 = Spec.limb_to_word al offset in
[@inline_let]
let wv_13 = Spec.limb_to_word al (offset >>. (size (bits (Spec.wt al)))) in
// SH: TODO: for some reason, ``ones`` below doesn't get inlined by KaRaMeL,
// causing an extraction problem. The 3 lines below are a hack to fix
// extraction for the time being:
// [> let wv_14 = if flag then (ones (Spec.wt al) SEC) else (Spec.zero al) in
// After investigation, it is because ones is [@(strict_on_arguments [0])],
// and so isn't unfolded if its first argument is not normalized to a constant.
// However, the first argument should always be normalized (I checked the
// output generated by KaRaMeL and the definitions).
(**) normalize_term_spec (Spec.wt al);
[@inline_let] let wt_al = normalize_term (Spec.wt al) in
let wv_14 = if flag then ones wt_al SEC else (Spec.zero al) in
// end of the TODO
let wv_15 = Spec.zero al in
create_row mask wv_12 wv_13 wv_14 wv_15;
copy_state wv s_iv;
let wv3 = rowi wv 3ul in
xor_row wv3 mask;
pop_frame();
let h1 = ST.get() in
assert(modifies (loc wv) h0 h1);
Lib.Sequence.eq_intro (state_v h1 wv) (Spec.blake2_compress1 al (state_v h0 s_iv) offset flag)
inline_for_extraction noextract
val blake2_compress2 :
#al:Spec.alg
-> #ms:m_spec
-> wv: state_p al ms
-> m: block_w al ->
Stack unit
(requires (fun h -> live h wv /\ live h m /\ disjoint wv m))
(ensures (fun h0 _ h1 -> modifies1 wv h0 h1
/\ state_v h1 wv == Spec.blake2_compress2 al (state_v h0 wv) (as_seq h0 m)))
#push-options "--z3rlimit 400"
let blake2_compress2 #al #ms wv m =
let h0 = ST.get () in
[@inline_let]
let a_spec = Spec.state al in
[@inline_let]
let refl h = state_v h wv in
[@inline_let]
let footprint = Ghost.hide(loc wv) in
[@inline_let]
let spec h = Spec.blake2_round al h.[|m|] in
loop_refl h0 (rounds_t al) a_spec refl footprint spec
(fun i ->
Loops.unfold_repeati (Spec.rounds al) (spec h0) (state_v h0 wv) (v i);
blake2_round wv m i)
#pop-options
inline_for_extraction noextract
val blake2_compress3 :
#al:Spec.alg
-> #ms:m_spec
-> s_iv:state_p al ms
-> wv:state_p al ms ->
Stack unit
(requires (fun h -> live h s_iv /\ live h wv /\ disjoint s_iv wv))
(ensures (fun h0 _ h1 -> modifies (loc s_iv) h0 h1
/\ state_v h1 s_iv == Spec.blake2_compress3 al (state_v h0 wv) (state_v h0 s_iv)))
let blake2_compress3 #al #ms s_iv wv =
let h0 = ST.get() in
let s0 = rowi s_iv 0ul in
let s1 = rowi s_iv 1ul in
let r0 = rowi wv 0ul in
let r1 = rowi wv 1ul in
let r2 = rowi wv 2ul in
let r3 = rowi wv 3ul in
assert (disjoint s0 wv);
assert (disjoint wv s0);
assert (disjoint s1 wv);
assert (disjoint wv s1);
assert (disjoint r0 s0);
assert (disjoint r2 s0);
assert (disjoint r1 s1);
assert (disjoint r3 s1);
xor_row s0 r0;
let h1 = ST.get() in
xor_row s0 r2;
let h2 = ST.get() in
xor_row s1 r1;
let h3 = ST.get() in
xor_row s1 r3;
let h4 = ST.get() in
assert (modifies (loc s_iv) h0 h4);
let open Lib.Sequence in
assert (row_v h0 r0 == (state_v h0 wv).[0]);
assert (row_v h1 r2 == (state_v h0 wv).[2]);
assert (row_v h4 s0 == Spec.(((state_v h0 s_iv).[0] ^| (state_v h0 wv).[0]) ^| (state_v h0 wv).[2]));
assert (row_v h4 s1 == Spec.(((state_v h0 s_iv).[1] ^| (state_v h0 wv).[1]) ^| (state_v h0 wv).[3]));
eq_intro (state_v h2 s_iv) ((state_v h0 s_iv).[0] <- row_v h4 s0);
eq_intro (state_v h4 s_iv) ((state_v h2 s_iv).[1] <- row_v h4 s1);
eq_intro (state_v h4 s_iv) (Spec.blake2_compress3 al (state_v h0 wv) (state_v h0 s_iv))
inline_for_extraction noextract
let compress_t (al:Spec.alg) (ms:m_spec) =
wv:state_p al ms
-> s: state_p al ms
-> m: block_p al
-> offset: Spec.limb_t al
-> flag: bool ->
Stack unit
(requires (fun h -> live h wv /\ live h s /\ live h m /\ disjoint s m /\ disjoint wv s /\ disjoint wv m))
(ensures (fun h0 _ h1 -> modifies (loc s |+| loc wv) h0 h1
/\ state_v h1 s == Spec.blake2_compress al (state_v h0 s) h0.[|m|] offset flag))
inline_for_extraction noextract
val blake2_compress: #al:Spec.alg -> #ms:m_spec -> compress_t al ms
let blake2_compress #al #ms wv s m offset flag =
push_frame();
let m_w = create 16ul (Spec.zero al) in
blake2_compress0 #al m m_w;
blake2_compress1 wv s offset flag;
blake2_compress2 wv m_w;
blake2_compress3 s wv;
pop_frame()
inline_for_extraction noextract
let blake2_update_block_st (al:Spec.alg) (ms:m_spec) =
wv:state_p al ms
-> hash: state_p al ms
-> flag: bool
-> totlen: Spec.limb_t al{v totlen <= Spec.max_limb al}
-> d: block_p al ->
Stack unit
(requires (fun h -> live h wv /\ live h hash /\ live h d /\ disjoint hash d /\ disjoint wv hash /\ disjoint wv d))
(ensures (fun h0 _ h1 -> modifies (loc hash |+| loc wv) h0 h1
/\ state_v h1 hash == Spec.blake2_update_block al flag (v totlen) h0.[|d|] (state_v h0 hash)))
inline_for_extraction noextract
val blake2_update_block: #al:Spec.alg -> #ms:m_spec -> blake2_update_block_st al ms
let blake2_update_block #al #ms wv hash flag totlen d =
blake2_compress wv hash d totlen flag
inline_for_extraction noextract
let blake2_update1_st (al:Spec.alg) (ms:m_spec) =
#len:size_t
-> wv: state_p al ms
-> hash: state_p al ms
-> prev: Spec.limb_t al{v prev + v len <= Spec.max_limb al}
-> d: lbuffer uint8 len
-> i: size_t{v i < length d / Spec.size_block al} ->
Stack unit
(requires (fun h -> live h wv /\ live h hash /\ live h d /\ disjoint hash d /\ disjoint wv hash /\ disjoint wv d))
(ensures (fun h0 _ h1 -> modifies (loc hash |+| loc wv) h0 h1
/\ state_v h1 hash == Spec.blake2_update1 al (v prev) h0.[|d|] (v i) (state_v h0 hash)))
inline_for_extraction noextract
val blake2_update1: #al:Spec.alg -> #ms:m_spec -> blake2_update_block: blake2_update_block_st al ms -> blake2_update1_st al ms
let blake2_update1 #al #ms blake2_update_block #len wv hash prev d i =
let totlen = prev +. size_to_limb al ((i+!1ul) *! size_block al) in
assert (v totlen == v prev + (v i + 1) * Spec.size_block al);
let b = sub d (i *. size_block al) (size_block al) in
let h = ST.get() in
assert (as_seq h b == Spec.get_blocki al (as_seq h d) (v i));
blake2_update_block wv hash false totlen b
inline_for_extraction noextract
let blake2_update_last_st (al:Spec.alg) (ms:m_spec) =
#len:size_t
-> wv: state_p al ms
-> hash: state_p al ms
-> prev: Spec.limb_t al{v prev + v len <= Spec.max_limb al}
-> rem: size_t {v rem <= v len /\ v rem <= Spec.size_block al}
-> d: lbuffer uint8 len ->
Stack unit
(requires (fun h -> live h wv /\ live h hash /\ live h d /\ disjoint hash d /\ disjoint wv hash /\ disjoint wv d))
(ensures (fun h0 _ h1 -> modifies (loc hash |+| loc wv) h0 h1
/\ state_v h1 hash == Spec.blake2_update_last al (v prev) (v rem) h0.[|d|] (state_v h0 hash)))
inline_for_extraction noextract
val blake2_update_last:
#al:Spec.alg
-> #ms:m_spec
-> blake2_update_block: blake2_update_block_st al ms
-> blake2_update_last_st al ms
let blake2_update_last #al #ms blake2_update_block #len wv hash prev rem d =
let h0 = ST.get () in
[@inline_let]
let spec _ h1 = state_v h1 hash == Spec.blake2_update_last al (v prev) (v rem) h0.[|d|] (state_v h0 hash) in
salloc1 h0 (size_block al) (u8 0) (Ghost.hide (loc hash |+| loc wv)) spec
(fun last_block ->
let last = sub d (len -! rem) rem in
let h1 = ST.get() in
update_sub last_block 0ul rem last;
let h2 = ST.get() in
as_seq_gsub h1 d (len -! rem) rem;
assert (as_seq h1 last == Seq.sub (as_seq h1 d) (v len - v rem) (v rem));
assert (as_seq h1 last == Seq.slice (as_seq h0 d) (v len - v rem) (v len));
assert (as_seq h2 last_block == Spec.get_last_padded_block al (as_seq h0 d) (v rem));
let totlen = prev +. (size_to_limb al len) in
blake2_update_block wv hash true totlen last_block;
let h3 = ST.get() in
assert (v totlen == v prev + v len);
assert (state_v h3 hash == Spec.blake2_update_block al true (v totlen) (as_seq h2 last_block) (state_v h0 hash)))
inline_for_extraction noextract
let blake2_init_st (al:Spec.alg) (ms:m_spec) =
hash: state_p al ms
-> kk: size_t{v kk <= Spec.max_key al}
-> nn: size_t{1 <= v nn /\ v nn <= Spec.max_output al} ->
Stack unit
(requires (fun h -> live h hash))
(ensures (fun h0 _ h1 -> modifies (loc hash) h0 h1 /\
state_v h1 hash == Spec.blake2_init_hash al (Spec.blake2_default_params al) (v kk) (v nn)))
inline_for_extraction noextract
val serialize_params (al:Spec.alg)
(kk:size_t{v kk <= Spec.max_key al})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output al})
(p: blake2_params al)
(b: lbuffer (word_t al) 8ul)
: Stack unit
(requires fun h ->
live h b /\
blake2_params_inv h p /\
LowStar.Buffer.loc_disjoint (loc b) (blake2_params_loc p) /\
as_seq h b == Seq.create 8 (Spec.nat_to_word al 0)
)
(ensures fun h0 _ h1 ->
modifies (loc b) h0 h1 /\
as_seq h1 b == Spec.serialize_blake2_params
(Spec.set_key_length (Spec.set_digest_length (blake2_params_v h0 p) (v nn)) (v kk)))
#push-options "--z3rlimit 100 --fuel 0"
inline_for_extraction noextract
let serialize_params_blake2s
(kk:size_t{v kk <= Spec.max_key Spec.Blake2S})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output Spec.Blake2S})
(p: blake2_params Spec.Blake2S)
(b: lbuffer (word_t Spec.Blake2S) 8ul)
: Stack unit
(requires fun h -> live h b /\
blake2_params_inv h p /\
LowStar.Buffer.loc_disjoint (loc b) (blake2_params_loc p) /\
as_seq h b == Seq.create 8 (u32 0)
)
(ensures fun h0 _ h1 ->
modifies (loc b) h0 h1 /\
as_seq h1 b == Spec.serialize_blake2_params
(Spec.set_key_length (Spec.set_digest_length (blake2_params_v h0 p) (v nn)) (v kk)))
= let h0 = ST.get () in
[@inline_let]
let kk_shift_8 = shift_left (to_u32 kk) (size 8) in
[@inline_let]
let fanout_shift_16 = shift_left (to_u32 p.fanout) (size 16) in
[@inline_let]
let depth_shift_24 = shift_left (to_u32 p.depth) (size 24) in
[@inline_let]
let v0 = (to_u32 nn) ^. kk_shift_8 ^. fanout_shift_16 ^. depth_shift_24 in
[@inline_let]
let v1 = p.leaf_length in
[@inline_let]
let v2 = p.node_offset in
[@inline_let]
let node_depth_shift_16 = shift_left (to_u32 p.node_depth) (size 16) in
[@inline_let]
let inner_length_shift_16 = shift_left (to_u32 p.inner_length) (size 24) in
[@inline_let]
let v3 = (to_u32 p.xof_length) ^. node_depth_shift_16 ^. inner_length_shift_16 in
uints_from_bytes_le (sub b 4ul 2ul) p.salt;
uints_from_bytes_le (sub b 6ul 2ul) p.personal;
// AF: Putting these writes *after* modifications on a subbuffer of b helps with modifies-reasoning:
// By putting them before, F* struggles with proving that b[0..3] is not modified by uints_from_bytes_le
b.(0ul) <- v0;
b.(1ul) <- v1;
b.(2ul) <- v2;
b.(3ul) <- v3;
let h1 = ST.get () in
let aux () : Lemma (as_seq h1 b `Seq.equal` Spec.serialize_blake2s_params
(Spec.set_key_length (Spec.set_digest_length (blake2_params_v h0 p) (v nn)) (v kk))) =
let open Lib.Sequence in
let open Lib.ByteSequence in
let s0 = (u32 (v nn)) ^.
(u32 (v kk) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le (as_seq h0 (get_salt p)) in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le (as_seq h0 (get_personal p)) in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
// There seems to be something not triggering with createL, requiring the
// following lemma calls, and assert_norms to relate List.index to the
// actual elements
assert_norm (List.Tot.index l 0 == s0);
assert_norm (List.Tot.index l 1 == s1);
assert_norm (List.Tot.index l 2 == s2);
assert_norm (List.Tot.index l 3 == s3);
assert_norm (List.Tot.index l 4 == s4);
assert_norm (List.Tot.index l 5 == s5);
assert_norm (List.Tot.index l 6 == s6);
assert_norm (List.Tot.index l 7 == s7);
of_list_index l 0;
of_list_index l 1;
of_list_index l 2;
of_list_index l 3;
of_list_index l 4;
of_list_index l 5;
of_list_index l 6;
of_list_index l 7
in
aux()
inline_for_extraction noextract
let serialize_params_blake2b
(kk:size_t{v kk <= Spec.max_key Spec.Blake2B})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output Spec.Blake2B})
(p: blake2_params Spec.Blake2B)
(b: lbuffer (word_t Spec.Blake2B) 8ul)
: Stack unit
(requires fun h -> live h b /\
blake2_params_inv #Spec.Blake2B h p /\
LowStar.Buffer.loc_disjoint (loc b) (blake2_params_loc p) /\
as_seq h b == Seq.create 8 (u64 0)
)
(ensures fun h0 _ h1 ->
modifies (loc b) h0 h1 /\
as_seq h1 b == Spec.serialize_blake2_params
(Spec.set_key_length (Spec.set_digest_length (blake2_params_v h0 p) (v nn)) (v kk)))
= let h0 = ST.get () in
[@inline_let]
let kk_shift_8 = shift_left (to_u64 kk) (size 8) in
[@inline_let]
let fanout_shift_16 = shift_left (to_u64 p.fanout) (size 16) in
[@inline_let]
let depth_shift_24 = shift_left (to_u64 p.depth) (size 24) in
[@inline_let]
let leaf_length_shift_32 = shift_left (to_u64 p.leaf_length) (size 32) in
[@inline_let]
let v0 = (to_u64 nn) ^. kk_shift_8 ^. fanout_shift_16 ^. depth_shift_24 ^. leaf_length_shift_32 in
[@inline_let]
let xof_length_shift_32 = shift_left (to_u64 p.xof_length) (size 32) in
[@inline_let]
let v1 = (to_u64 p.node_offset) ^. xof_length_shift_32 in
[@inline_let]
let inner_length_shift_8 = shift_left (to_u64 p.inner_length) (size 8) in
[@inline_let]
let v2 = (to_u64 p.node_depth) ^. inner_length_shift_8 in
uints_from_bytes_le (sub b 4ul 2ul) p.salt;
uints_from_bytes_le (sub b 6ul 2ul) p.personal;
b.(0ul) <- v0;
b.(1ul) <- v1;
b.(2ul) <- v2;
b.(3ul) <- (u64 0);
let h1 = ST.get () in
let aux () : Lemma (as_seq h1 b `Seq.equal` Spec.serialize_blake2b_params
(Spec.set_key_length (Spec.set_digest_length (blake2_params_v h0 p) (v nn)) (v kk))) =
let open Lib.Sequence in
let open Lib.ByteSequence in
let s0 = (u64 (v nn)) ^.
(u64 (v kk) <<. (size 8)) ^.
(u64 (v p.fanout) <<. (size 16)) ^.
(u64 (v p.depth) <<. (size 24)) ^.
(u64 (v p.leaf_length) <<. (size 32)) in
let s1 = (u64 (v p.node_offset)) ^.
(u64 (v p.xof_length) <<. (size 32)) in
// The serialization corresponding to s2 contains node_depth and inner_length,
// followed by the 14 reserved bytes which always seem to be zeros, and can hence
// be ignored when building the corresponding uint64 using xor's
let s2 = (u64 (v p.node_depth)) ^.
(u64 (v p.inner_length) <<. (size 8)) in
// s3 corresponds to the remaining of the reserved bytes
let s3 = u64 0 in
let salt_u64: lseq uint64 2 = uints_from_bytes_le (as_seq h0 (get_salt p)) in
let s4 = salt_u64.[0] in
let s5 = salt_u64.[1] in
let personal_u64: lseq uint64 2 = uints_from_bytes_le (as_seq h0 (get_personal p)) in
let s6 = personal_u64.[0] in
let s7 = personal_u64.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
// There seems to be something not triggering with createL, requiring the
// following lemma calls, and assert_norms to relate List.index to the
// actual elements
assert_norm (List.Tot.index l 0 == s0);
assert_norm (List.Tot.index l 1 == s1);
assert_norm (List.Tot.index l 2 == s2);
assert_norm (List.Tot.index l 3 == s3);
assert_norm (List.Tot.index l 4 == s4);
assert_norm (List.Tot.index l 5 == s5);
assert_norm (List.Tot.index l 6 == s6);
assert_norm (List.Tot.index l 7 == s7);
of_list_index l 0;
of_list_index l 1;
of_list_index l 2;
of_list_index l 3;
of_list_index l 4;
of_list_index l 5;
of_list_index l 6;
of_list_index l 7
in
aux()
#pop-options
let serialize_params al kk nn p b =
match al with
| Spec.Blake2S -> serialize_params_blake2s kk nn p b
| Spec.Blake2B -> serialize_params_blake2b kk nn p b
inline_for_extraction noextract
val blake2_init:
#al:Spec.alg
-> #ms:m_spec
-> blake2_init_st al ms
let blake2_init #al #ms hash kk nn =
push_frame ();
let h0 = ST.get() in
let tmp = create 8ul (Spec.nat_to_word al 0) in
let r0 = rowi hash 0ul in
let r1 = rowi hash 1ul in
let r2 = rowi hash 2ul in
let r3 = rowi hash 3ul in
let iv0 = get_iv al 0ul in
let iv1 = get_iv al 1ul in
let iv2 = get_iv al 2ul in
let iv3 = get_iv al 3ul in
let iv4 = get_iv al 4ul in
let iv5 = get_iv al 5ul in
let iv6 = get_iv al 6ul in
let iv7 = get_iv al 7ul in
create_row #al #ms r2 iv0 iv1 iv2 iv3;
create_row #al #ms r3 iv4 iv5 iv6 iv7;
let salt = create (salt_len al) (u8 0) in
let personal = create (personal_len al) (u8 0) in
let p = create_default_params al salt personal in
serialize_params al kk nn p tmp;
let tmp0 = tmp.(0ul) in
let tmp1 = tmp.(1ul) in
let tmp2 = tmp.(2ul) in
let tmp3 = tmp.(3ul) in
let tmp4 = tmp.(4ul) in
let tmp5 = tmp.(5ul) in
let tmp6 = tmp.(6ul) in
let tmp7 = tmp.(7ul) in
let iv0' = iv0 ^. tmp0 in
let iv1' = iv1 ^. tmp1 in
let iv2' = iv2 ^. tmp2 in
let iv3' = iv3 ^. tmp3 in
let iv4' = iv4 ^. tmp4 in
let iv5' = iv5 ^. tmp5 in
let iv6' = iv6 ^. tmp6 in
let iv7' = iv7 ^. tmp7 in
create_row #al #ms r0 iv0' iv1' iv2' iv3';
create_row #al #ms r1 iv4' iv5' iv6' iv7';
let h1 = ST.get() in
assert (disjoint hash tmp);
assert (modifies (loc hash `union` loc tmp) h0 h1);
Lib.Sequence.eq_intro (state_v h1 hash) (Spec.blake2_init_hash al (Spec.blake2_default_params al) (v kk) (v nn));
pop_frame ()
#push-options "--z3rlimit 100 --max_fuel 0 --max_ifuel 0"
let _ : squash (inversion Spec.alg) = allow_inversion Spec.alg
inline_for_extraction noextract
val split_blocks: al:Spec.alg -> len:size_t -> r:(size_t & size_t){
let (x,y) = r in
let (sx,sy) = Spec.split al (v len) in
sx == v x /\
sy == v y}
let split_blocks al len =
let nb = len /. size_block al in
let rem = len %. size_block al in
(if rem =. 0ul && nb >. 0ul then nb -! 1ul else nb),
(if rem =. 0ul && nb >. 0ul then size_block al else rem)
inline_for_extraction noextract
let blake2_update_multi_st (al : Spec.alg) (ms : m_spec) =
#len:size_t
-> wv: state_p al ms
-> hash: state_p al ms
-> prev: Spec.limb_t al{v prev + v len <= Spec.max_limb al}
-> blocks: lbuffer uint8 len
-> nb : size_t{length blocks >= v nb * v (size_block al) } ->
Stack unit
(requires (fun h -> live h wv /\ live h hash /\ live h blocks /\
disjoint hash blocks /\ disjoint wv hash /\ disjoint wv blocks))
(ensures (fun h0 _ h1 ->
modifies (loc hash |+| loc wv) h0 h1 /\
state_v h1 hash == repeati (v nb) (Spec.blake2_update1 al (v prev) h0.[|blocks|])
(state_v h0 hash)))
inline_for_extraction noextract
val blake2_update_multi (#al : Spec.alg) (#ms : m_spec) :
blake2_update_block:blake2_update_block_st al ms
-> blake2_update_multi_st al ms
let blake2_update_multi #al #ms blake2_update_block #len wv hash prev blocks nb =
let h0 = ST.get () in
[@inline_let]
let a_spec = Spec.state al in
[@inline_let]
let refl h = state_v h hash in
[@inline_let]
let footprint = Ghost.hide(loc hash |+| loc wv) in
[@inline_let]
let spec h = Spec.blake2_update1 al (v prev) h.[|blocks|] in
loop_refl h0 nb a_spec refl footprint spec
(fun i ->
Loops.unfold_repeati (v nb) (spec h0) (state_v h0 hash) (v i);
blake2_update1 #al #ms blake2_update_block #len wv hash prev blocks i)
inline_for_extraction noextract
let blake2_update_blocks_st (al : Spec.alg) (ms : m_spec) =
#len:size_t
-> wv: state_p al ms
-> hash: state_p al ms
-> prev: Spec.limb_t al{v prev + v len <= Spec.max_limb al}
-> blocks: lbuffer uint8 len ->
Stack unit
(requires (fun h -> live h wv /\ live h hash /\ live h blocks /\ disjoint hash blocks /\ disjoint wv hash /\ disjoint wv blocks))
(ensures (fun h0 _ h1 -> modifies (loc hash |+| loc wv) h0 h1 /\
state_v h1 hash ==
Spec.blake2_update_blocks al (v prev) h0.[|blocks|] (state_v h0 hash)))
inline_for_extraction noextract
val blake2_update_blocks (#al : Spec.alg) (#ms : m_spec) :
blake2_update_multi_st al ms
-> blake2_update_last_st al ms
-> blake2_update_blocks_st al ms
let blake2_update_blocks #al #ms blake2_update_multi blake2_update_last #len wv hash prev blocks =
let (nb,rem) = split_blocks al len in
blake2_update_multi wv hash prev blocks nb;
blake2_update_last #len wv hash prev rem blocks
inline_for_extraction noextract
let blake2_finish_st (al:Spec.alg) (ms:m_spec) =
nn: size_t{1 <= v nn /\ v nn <= Spec.max_output al}
-> output: lbuffer uint8 nn
-> hash: state_p al ms ->
Stack unit
(requires (fun h -> live h hash /\ live h output /\ disjoint output hash))
(ensures (fun h0 _ h1 -> modifies (loc output) h0 h1
/\ h1.[|output|] == Spec.blake2_finish al (state_v h0 hash) (v nn)))
inline_for_extraction noextract
val blake2_finish:#al:Spec.alg -> #ms:m_spec -> blake2_finish_st al ms
let blake2_finish #al #ms nn output hash =
let h0 = ST.get () in
[@inline_let]
let double_row = 2ul *. size_row al in
[@inline_let]
let spec _ h1 = h1.[|output|] == Spec.blake2_finish al (state_v h0 hash) (v nn) in
salloc1 h0 double_row (u8 0) (Ghost.hide (loc output)) spec
(fun full ->
let first = sub full 0ul (size_row al) in
let second = sub full (size_row al) (size_row al) in
let row0 = rowi hash 0ul in
let row1 = rowi hash 1ul in
store_row first row0;
store_row second row1;
let h1 = ST.get() in
Lib.Sequence.eq_intro (as_seq h1 full)
(Lib.Sequence.(as_seq h1 (gsub full 0ul (size_row al)) @|
as_seq h1 (gsub full (size_row al) (size_row al))));
let final = sub full (size 0) nn in
copy output final)
inline_for_extraction noextract
let blake2_update_key_st (al:Spec.alg) (ms:m_spec) =
wv:state_p al ms
-> hash: state_p al ms
-> kk: size_t{v kk > 0 /\ v kk <= Spec.max_key al}
-> k: lbuffer uint8 kk
-> ll: size_t ->
Stack unit
(requires (fun h -> live h wv /\ live h hash /\ live h k /\
disjoint hash k /\ disjoint wv hash /\ disjoint wv k))
(ensures (fun h0 _ h1 -> modifies (loc hash |+| loc wv) h0 h1
/\ state_v h1 hash == Spec.blake2_update_key al (v kk) h0.[|k|] (v ll) (state_v h0 hash)))
inline_for_extraction noextract
val blake2_update_key:
#al:Spec.alg
-> #ms:m_spec
-> blake2_update_block_st al ms
-> blake2_update_key_st al ms
inline_for_extraction noextract
let blake2_update_key #al #ms blake2_update_block wv hash kk k ll =
let lb = size_to_limb al (size_block al) in
assert (v lb = Spec.size_block al);
let h0 = ST.get () in
salloc1 h0 (size_block al) (u8 0) (Ghost.hide (loc hash |+| loc wv))
(fun _ h1 -> live h1 hash /\ state_v h1 hash == Spec.blake2_update_key al (v kk) h0.[|k|] (v ll) (state_v h0 hash))
(fun key_block ->
update_sub key_block 0ul kk k;
let h1 = ST.get() in
if ll =. 0ul then
blake2_update_block wv hash true lb key_block
else
blake2_update_block wv hash false lb key_block)
inline_for_extraction noextract
let blake2_update_st (al:Spec.alg) (ms:m_spec) =
wv:state_p al ms
-> hash: state_p al ms
-> kk: size_t{v kk <= Spec.max_key al}
-> k: lbuffer uint8 kk
-> ll: size_t
-> d: lbuffer uint8 ll ->
Stack unit
(requires (fun h -> live h wv /\ live h hash /\ live h k /\ live h d /\
disjoint hash k /\ disjoint wv hash /\ disjoint wv k /\
disjoint hash d /\ disjoint wv d /\ disjoint d k))
(ensures (fun h0 _ h1 -> modifies (loc hash |+| loc wv) h0 h1
/\ state_v h1 hash == Spec.blake2_update al (v kk) h0.[|k|] h0.[|d|] (state_v h0 hash)))
inline_for_extraction noextract
val blake2_update:
#al:Spec.alg
-> #ms:m_spec
-> blake2_update_key_st al ms
-> blake2_update_blocks_st al ms
-> blake2_update_st al ms
inline_for_extraction noextract
let blake2_update #al #ms blake2_update_key blake2_update_blocks
wv hash kk k ll d =
let lb = size_to_limb al (size_block al) in
assert (v lb = Spec.size_block al);
if kk >. 0ul then (
blake2_update_key wv hash kk k ll;
if ll =. 0ul then ()
else blake2_update_blocks wv hash lb d)
else blake2_update_blocks wv hash (size_to_limb al 0ul) d
inline_for_extraction noextract
let blake2_st (al:Spec.alg) (ms:m_spec) =
output: buffer_t MUT uint8
-> output_len: size_t{v output_len == length output /\ 1 <= v output_len /\ v output_len <= Spec.max_output al}
-> input: buffer_t MUT uint8
-> input_len: size_t{v input_len == length input}
-> key: buffer_t MUT uint8
-> key_len: size_t{v key_len == length key /\ v key_len <= Spec.max_key al} ->
Stack unit
(requires (fun h -> live h output /\ live h input /\ live h key
/\ disjoint output input /\ disjoint output key /\ disjoint input key))
(ensures (fun h0 _ h1 -> modifies1 output h0 h1
/\ h1.[|(output <: lbuffer uint8 output_len)|] == Spec.blake2 al h0.[|(input <: lbuffer uint8 input_len)|] (Spec.blake2_default_params al) (v key_len) h0.[|(key <: lbuffer uint8 key_len)|] (v output_len)))
inline_for_extraction noextract
val blake2:
#al:Spec.alg
-> #ms:m_spec
-> blake2_init_st al ms
-> blake2_update_st al ms
-> blake2_finish_st al ms
-> blake2_st al ms | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Impl.Blake2.Constants.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Blake2.Generic.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Constants",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
blake2_init: Hacl.Impl.Blake2.Generic.blake2_init_st al ms ->
blake2_update: Hacl.Impl.Blake2.Generic.blake2_update_st al ms ->
blake2_finish: Hacl.Impl.Blake2.Generic.blake2_finish_st al ms
-> Hacl.Impl.Blake2.Generic.blake2_st al ms | Prims.Tot | [
"total"
] | [] | [
"Spec.Blake2.Definitions.alg",
"Hacl.Impl.Blake2.Core.m_spec",
"Hacl.Impl.Blake2.Generic.blake2_init_st",
"Hacl.Impl.Blake2.Generic.blake2_update_st",
"Hacl.Impl.Blake2.Generic.blake2_finish_st",
"Lib.Buffer.buffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint8",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"Lib.Buffer.length",
"Prims.op_LessThanOrEqual",
"Spec.Blake2.Definitions.max_output",
"Spec.Blake2.Definitions.max_key",
"Lib.Buffer.salloc1",
"Hacl.Impl.Blake2.Core.element_t",
"Prims.unit",
"FStar.Ghost.hide",
"LowStar.Monotonic.Buffer.loc",
"Lib.Buffer.loc",
"Lib.Buffer.lbuffer",
"Lib.Buffer.op_Bar_Plus_Bar",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims._assert",
"Lib.IntTypes.max_size_t",
"Spec.Blake2.Definitions.max_limb",
"Prims.logical",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Buffer.op_Brack_Lens_Access",
"Spec.Blake2.blake2",
"Spec.Blake2.Definitions.blake2_default_params",
"Hacl.Impl.Blake2.Core.zero_element",
"Lib.IntTypes.int_t",
"Lib.IntTypes.mul_mod",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Hacl.Impl.Blake2.Core.row_len",
"Hacl.Impl.Blake2.Core.le_sigh"
] | [] | false | false | false | false | false | let blake2
#al
#ms
blake2_init
blake2_update
blake2_finish
output
output_len
input
input_len
key
key_len
=
| [@@ inline_let ]let stlen = le_sigh al ms in
[@@ inline_let ]let stzero = zero_element al ms in
let h0 = ST.get () in
[@@ inline_let ]let spec _ h1 =
h1.[| output |] ==
Spec.blake2 al
h0.[| (input <: lbuffer uint8 input_len) |]
(Spec.blake2_default_params al)
(v key_len)
h0.[| key |]
(v output_len)
in
salloc1 h0
stlen
stzero
(Ghost.hide (loc output))
spec
(fun h ->
assert (max_size_t <= Spec.max_limb al);
let h1 = ST.get () in
salloc1 h1
stlen
stzero
(Ghost.hide (loc output |+| loc h))
spec
(fun wv ->
blake2_init h key_len output_len;
blake2_update wv h key_len key input_len input;
blake2_finish output_len output h)) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.var | val var : Type0 | let var = nat | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 8,
"start_col": 0,
"start_line": 8
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.nat"
] | [] | false | false | false | true | true | let var =
| nat | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.index | val index : Type0 | let index = nat | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 9,
"start_col": 0,
"start_line": 9
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.nat"
] | [] | false | false | false | true | true | let index =
| nat | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.tun | val tun : FStar.Stubs.Reflection.Types.term | let tun = R.pack_ln R.Tv_Unknown | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 11,
"start_col": 0,
"start_line": 11
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_Unknown"
] | [] | false | false | false | true | false | let tun =
| R.pack_ln R.Tv_Unknown | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.ln | val ln : e: DependentBoolRefinement.src_exp -> Prims.bool | let ln e = ln' e (-1) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 59,
"start_col": 0,
"start_line": 59
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.ln'",
"Prims.op_Minus",
"Prims.bool"
] | [] | false | false | false | true | false | let ln e =
| ln' e (- 1) | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.ln_ty | val ln_ty : t: DependentBoolRefinement.src_ty -> Prims.bool | let ln_ty t = ln_ty' t (-1) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 60,
"start_col": 0,
"start_line": 60
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: DependentBoolRefinement.src_ty -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.ln_ty'",
"Prims.op_Minus",
"Prims.bool"
] | [] | false | false | false | true | false | let ln_ty t =
| ln_ty' t (- 1) | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.open_exp | val open_exp : e: DependentBoolRefinement.src_exp -> v: DependentBoolRefinement.var
-> DependentBoolRefinement.src_exp | let open_exp e v = open_exp' e (EVar v) 0 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 100,
"start_col": 0,
"start_line": 100
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> v: DependentBoolRefinement.var
-> DependentBoolRefinement.src_exp | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.var",
"DependentBoolRefinement.open_exp'",
"DependentBoolRefinement.EVar"
] | [] | false | false | false | true | false | let open_exp e v =
| open_exp' e (EVar v) 0 | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.close_exp | val close_exp : e: DependentBoolRefinement.src_exp -> v: DependentBoolRefinement.var
-> DependentBoolRefinement.src_exp | let close_exp e v = close_exp' e v 0 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 101,
"start_col": 0,
"start_line": 101
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> v: DependentBoolRefinement.var
-> DependentBoolRefinement.src_exp | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.var",
"DependentBoolRefinement.close_exp'"
] | [] | false | false | false | true | false | let close_exp e v =
| close_exp' e v 0 | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.open_with | val open_with : e: DependentBoolRefinement.src_exp -> e': DependentBoolRefinement.src_exp
-> DependentBoolRefinement.src_exp | let open_with e e' = open_exp' e e' 0 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 102,
"start_col": 0,
"start_line": 102
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> e': DependentBoolRefinement.src_exp
-> DependentBoolRefinement.src_exp | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.open_exp'"
] | [] | false | false | false | true | false | let open_with e e' =
| open_exp' e e' 0 | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.open_ty | val open_ty : t: DependentBoolRefinement.src_ty -> v: DependentBoolRefinement.var
-> DependentBoolRefinement.src_ty | let open_ty t v = open_ty' t (EVar v) 0 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 104,
"start_col": 0,
"start_line": 104
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: DependentBoolRefinement.src_ty -> v: DependentBoolRefinement.var
-> DependentBoolRefinement.src_ty | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.var",
"DependentBoolRefinement.open_ty'",
"DependentBoolRefinement.EVar"
] | [] | false | false | false | true | false | let open_ty t v =
| open_ty' t (EVar v) 0 | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.open_ty_with | val open_ty_with : t: DependentBoolRefinement.src_ty -> e: DependentBoolRefinement.src_exp
-> DependentBoolRefinement.src_ty | let open_ty_with t e = open_ty' t e 0 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 106,
"start_col": 0,
"start_line": 106
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: DependentBoolRefinement.src_ty -> e: DependentBoolRefinement.src_exp
-> DependentBoolRefinement.src_ty | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.open_ty'"
] | [] | false | false | false | true | false | let open_ty_with t e =
| open_ty' t e 0 | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.binding | val binding : Type0 | let binding = either src_ty src_eqn | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 147,
"start_col": 0,
"start_line": 147
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.either",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_eqn"
] | [] | false | false | false | true | true | let binding =
| either src_ty src_eqn | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.src_eqn | val src_eqn : Type0 | let src_eqn = src_exp & src_exp | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 146,
"start_col": 0,
"start_line": 146
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.src_exp"
] | [] | false | false | false | true | true | let src_eqn =
| src_exp & src_exp | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.close_ty | val close_ty : t: DependentBoolRefinement.src_ty -> v: DependentBoolRefinement.var
-> DependentBoolRefinement.src_ty | let close_ty t v = close_ty' t v 0 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 105,
"start_col": 0,
"start_line": 105
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: DependentBoolRefinement.src_ty -> v: DependentBoolRefinement.var
-> DependentBoolRefinement.src_ty | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.var",
"DependentBoolRefinement.close_ty'"
] | [] | false | false | false | true | false | let close_ty t v =
| close_ty' t v 0 | false |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.